{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys,os,shutil\n",
    "sys.path.append(r\"C:\\Reaserch\\CSTStudioSuite2021\\AMD64\\python_cst_libraries\")\n",
    "#sys.path.remove('C:\\\\Program Files (x86)\\\\CST Studio Suite 2021\\\\CST Studio Suite 2022\\\\AMD64\\\\python_cst_libraries') \n",
    "import cst\n",
    "import cst.interface\n",
    "import cst.results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "desEnv = cst.interface.DesignEnvironment()\n",
    "desEnv.set_quiet_mode(False)\n",
    "project = desEnv.open_project(model_path)\n",
    "modeler=project.modeler"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[22456]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "allpids = cst.interface.running_design_environments()\n",
    "allpids"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "cst_path='../model/test.cst'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_DE = cst.interface.DesignEnvironment()\n",
    "my_project = my_DE.new_mws()\n",
    "my_project.save(cst_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 创建CST文件,文件路径名为cst_path\n",
    "def creat_cst(cst_path):\n",
    "    allpids = cst.interface.running_design_environments()  # 以列表形式返回运行的cst环境名(PIDs)\n",
    "    DE_is_open = False   # 判断是否有打开的DE\n",
    "    for pid in allpids:\n",
    "        my_DE = cst.interface.DesignEnvironment.connect(pid)  # 连接到指定PID的DE\n",
    "        DE_is_open = True\n",
    "        break\n",
    "    if not DE_is_open:  # DE不存在，则新建一个DE，否则使用上面已打开的最后一个DE\n",
    "        my_DE = cst.interface.DesignEnvironment()\n",
    "    my_project = my_DE.new_mws()\n",
    "    my_project.save(cst_path)\n",
    "    return my_DE, my_project\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "allpids = cst.interface.running_design_environments() \n",
    "allpids"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cst_path='../model/test.cst'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 判断是否打开\n",
    "if cst.interface.running_design_environments()!=[]:\n",
    "    print(\"There are open CST Design\")\n",
    "else:\n",
    "    desEnv = cst.interface.DesignEnvironment()\n",
    "    desEnv.set_quiet_mode(False)\n",
    "    project = desEnv.open_project(cst_path)\n",
    "    modeler=project.modeler"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "c:\\Reaserch\\Code\\CEM\\AntennaGPT\\code\\../code/Patch_Antenna.cst\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import os\n",
    "#import numpy as np\n",
    "import cst.interface\n",
    "path = os.getcwd()#获取当前py文件所在文件夹\n",
    "filename = '../code/Patch_Antenna.cst'\n",
    "fullname = os.path.join(path,filename)\n",
    "print(fullname)\n",
    "cst = cst.interface.DesignEnvironment()\n",
    "mws = cst.new_mws()\n",
    "mws.save(fullname)\n",
    "modeler = mws.modeler\n",
    "#贴片天线建模基本参数\n",
    "a = 38.6 #贴片长\n",
    "b = 38 #贴片宽\n",
    "w = 1.46 #馈线宽，100欧姆传输线\n",
    "l = 40 #馈线长\n",
    "lx = 100 #基板长\n",
    "ly = 100 #基板宽\n",
    "ts = 2 #基板厚\n",
    "tm = 0.035 #金属层厚\n",
    "Frq = [2,2.7] #工作频率，单位：GHz\n",
    "\n",
    "#在CST中加入结构参数，方便后续手动在CST文件中进行操作\n",
    "modeler.add_to_history('StoreParameter','MakeSureParameterExists(\"a\", \"%f\")' % a)\n",
    "modeler.add_to_history('StoreParameter','MakeSureParameterExists(\"b\", \"%f\")' % b)\n",
    "modeler.add_to_history('StoreParameter','MakeSureParameterExists(\"w\", \"%f\")' % w)\n",
    "modeler.add_to_history('StoreParameter','MakeSureParameterExists(\"l\", \"%f\")' % l)\n",
    "modeler.add_to_history('StoreParameter','MakeSureParameterExists(\"lx\", \"%f\")' % lx)\n",
    "modeler.add_to_history('StoreParameter','MakeSureParameterExists(\"ly\", \"%f\")' % ly)\n",
    "modeler.add_to_history('StoreParameter','MakeSureParameterExists(\"ts\", \"%f\")' % ts)\n",
    "modeler.add_to_history('StoreParameter','MakeSureParameterExists(\"tm\", \"%f\")' % tm)\n",
    "#建模基本参数设置结束\n",
    "line_break = '\\n'#换行符，后面用于VBA代买的拼接用\n",
    "#全局单位初始化\n",
    "sCommand = ['With Units',\n",
    "            '.Geometry \"mm\"',\n",
    "            '.Frequency \"ghz\"',\n",
    "            '.Time \"ns\"',\n",
    "            'End With']\n",
    "sCommand = line_break.join(sCommand)\n",
    "modeler.add_to_history('define units', sCommand)\n",
    "#全局单位初始化结束\n",
    "\n",
    "#工作频率设置\n",
    "sCommand = 'Solver.FrequencyRange \"%f\",\"%f\"'  % (Frq[0],Frq[1])\n",
    "modeler.add_to_history('define frequency range', sCommand)\n",
    "#工作频率设置结束\n",
    "\n",
    "#背景材料设置\n",
    "sCommand = ['With Background',\n",
    "            '.ResetBackground',\n",
    "            '.Type \"Normal\"',\n",
    "            'End With']\n",
    "sCommand = line_break.join(sCommand)\n",
    "modeler.add_to_history('define background', sCommand)\n",
    "#背景材料设置结束\n",
    "\n",
    "#边界条件设置。\n",
    "sCommand = ['With Boundary',\n",
    "            '.Xmin \"expanded open\"',\n",
    "            '.Xmax \"expanded open\"',\n",
    "            '.Ymin \"expanded open\"',\n",
    "            '.Ymax \"expanded open\"',\n",
    "            '.Zmin \"expanded open\"',\n",
    "            '.Zmax \"expanded open\"',\n",
    "            '.Xsymmetry \"none\"',\n",
    "            '.Ysymmetry \"none\"',\n",
    "            '.Zsymmetry \"none\"',\n",
    "            'End With']\n",
    "sCommand = line_break.join(sCommand)\n",
    "modeler.add_to_history('define boundary', sCommand)\n",
    "#边界条件设置结束\n",
    "\n",
    "#新建所需介质材料\n",
    "er1 = 2.65\n",
    "sCommand = ['With Material',\n",
    "            '.Reset',\n",
    "            '.Name \"material1\"',\n",
    "            '.FrqType \"all\"',\n",
    "            '.Type \"Normal\"',\n",
    "            '.Epsilon %f' %er1,\n",
    "            '.Create',\n",
    "            'End With']\n",
    "sCommand = line_break.join(sCommand)\n",
    "modeler.add_to_history('define material: material265', sCommand)\n",
    "#新建所需介质材料结束\n",
    "\n",
    "#使Bounding Box显示\n",
    "sCommand = 'Plot.DrawBox \"True\"'\n",
    "modeler.add_to_history('switch bounding box', sCommand)\n",
    "#使Bounding Box显示结束\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#建模开始\n",
    "#调用Brick对象开始\n",
    "Str_Name='patch'\n",
    "Str_Component='Patch'\n",
    "Str_Material='PEC'\n",
    "#以下这一串可以写成函数\n",
    "sCommand = ['With Brick',\n",
    "            '.Reset',\n",
    "            '.Name \"%s\"' % Str_Name,\n",
    "            '.Component \"%s\"' % Str_Component,\n",
    "            '.Material \"%s\"' % Str_Material,\n",
    "            '.Xrange \"-a/2\",\"a/2\"',\n",
    "            '.Yrange \"-b/2\",\"b/2\"',\n",
    "            '.Zrange \"0\",\"tm\"',\n",
    "            '.Create',\n",
    "            'End With']\n",
    "sCommand = line_break.join(sCommand)\n",
    "modeler.add_to_history('define brick:%s:%s' % (Str_Component,Str_Name,), sCommand)\n",
    "#以上这一串可以写成函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Str_Name='wire1'\n",
    "Str_Component='Patch'\n",
    "Str_Material='PEC'\n",
    "Str_type='Bondwire'\n",
    "sCommand=['With Wire',\n",
    "    '.Reset',\n",
    "    '.Name \"%s\"' % Str_Name ,\n",
    "    '.Type \"%s\"' % Str_type  ,\n",
    "    '.Point1 \"0\", \"0\", \"0\", \"False\"',\n",
    "    '.Point2 \"1\", \"1\", \"0\", \"False\"',\n",
    "    '.Height \"1\" ',\n",
    "    '.Radius \"0.01\" ',\n",
    "    '.Add',\n",
    "    'End With'\n",
    "]\n",
    "sCommand = line_break.join(sCommand)\n",
    "modeler.add_to_history('define wire:%s:%s' % (Str_Component,Str_Name,), sCommand)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "def generate_neighbouring_triangles(vertex1, vertex2, vertex3, num_triangles):\n",
    "    triangles = []\n",
    "    for _ in range(num_triangles):\n",
    "        # Generate random small offsets for each vertex\n",
    "        offset1 = (random.uniform(-0.1, 0.1), random.uniform(-0.1, 0.1), random.uniform(-0.1, 0.1))\n",
    "        offset2 = (random.uniform(-0.1, 0.1), random.uniform(-0.1, 0.1), random.uniform(-0.1, 0.1))\n",
    "        offset3 = (random.uniform(-0.1, 0.1), random.uniform(-0.1, 0.1), random.uniform(-0.1, 0.1))\n",
    "        \n",
    "        # Apply offsets to original vertices\n",
    "        new_vertex1 = (vertex1[0] + offset1[0], vertex1[1] + offset1[1], vertex1[2] + offset1[2])\n",
    "        new_vertex2 = (vertex2[0] + offset2[0], vertex2[1] + offset2[1], vertex2[2] + offset2[2])\n",
    "        new_vertex3 = (vertex3[0] + offset3[0], vertex3[1] + offset3[1], vertex3[2] + offset3[2])\n",
    "        \n",
    "        # Append new triangle formed by the offset vertices\n",
    "        triangles.append((new_vertex1, new_vertex2, new_vertex3))\n",
    "    \n",
    "    return triangles\n",
    "\n",
    "def write_stl(triangles, filename):\n",
    "    with open(filename, 'w') as f:\n",
    "        f.write(\"solid GeneratedTriangles\\n\")\n",
    "        for triangle in triangles:\n",
    "            normal = calculate_normal(triangle[0], triangle[1], triangle[2])\n",
    "            f.write(\"  facet normal {} {} {}\\n\".format(normal[0], normal[1], normal[2]))\n",
    "            f.write(\"    outer loop\\n\")\n",
    "            for vertex in triangle:\n",
    "                f.write(\"      vertex {} {} {}\\n\".format(vertex[0], vertex[1], vertex[2]))\n",
    "            f.write(\"    endloop\\n\")\n",
    "            f.write(\"  endfacet\\n\")\n",
    "        f.write(\"endsolid GeneratedTriangles\\n\")\n",
    "\n",
    "def calculate_normal(vertex1, vertex2, vertex3):\n",
    "    # Calculate the cross product of two edges of the triangle to get the normal vector\n",
    "    edge1 = (vertex2[0] - vertex1[0], vertex2[1] - vertex1[1], vertex2[2] - vertex1[2])\n",
    "    edge2 = (vertex3[0] - vertex1[0], vertex3[1] - vertex1[1], vertex3[2] - vertex1[2])\n",
    "    normal = (\n",
    "        edge1[1] * edge2[2] - edge1[2] * edge2[1],\n",
    "        edge1[2] * edge2[0] - edge1[0] * edge2[2],\n",
    "        edge1[0] * edge2[1] - edge1[1] * edge2[0]\n",
    "    )\n",
    "    return normal\n",
    "\n",
    "# Example usage\n",
    "vertex1 = (0, 0, 0)\n",
    "vertex2 = (1, 0, 0)\n",
    "vertex3 = (0.5, 1, 0)\n",
    "num_triangles = 10  # Adjust the number of triangles as needed\n",
    "\n",
    "neighbouring_triangles = generate_neighbouring_triangles(vertex1, vertex2, vertex3, num_triangles)\n",
    "write_stl(neighbouring_triangles, \"../cst/generated_triangles.stl\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "import numpy as np\n",
    "\n",
    "def generate_neighbouring_triangles(vertex1, vertex2, vertex3, num_triangles):\n",
    "    triangles = []\n",
    "    # 计算三角形的法向量\n",
    "    normal = np.cross(np.array(vertex2) - np.array(vertex1), np.array(vertex3) - np.array(vertex1))\n",
    "    normal /= np.linalg.norm(normal)\n",
    "    for _ in range(num_triangles):\n",
    "        # 生成一个随机偏移向量，用于平移三角形\n",
    "        offset = np.array([random.uniform(-0.1, 0.1), random.uniform(-0.1, 0.1), 0])  # 在xy平面上偏移\n",
    "        # 应用偏移向量\n",
    "        new_vertex1 = np.array(vertex1) + offset\n",
    "        new_vertex2 = np.array(vertex2) + offset\n",
    "        new_vertex3 = np.array(vertex3) + offset\n",
    "        # 添加新的三角形\n",
    "        triangles.append((tuple(new_vertex1), tuple(new_vertex2), tuple(new_vertex3)))\n",
    "    return triangles\n",
    "\n",
    "def write_stl(triangles, filename):\n",
    "    with open(filename, 'w') as f:\n",
    "        f.write(\"solid GeneratedTriangles\\n\")\n",
    "        for triangle in triangles:\n",
    "            normal = calculate_normal(triangle[0], triangle[1], triangle[2])\n",
    "            f.write(\"  facet normal {} {} {}\\n\".format(normal[0], normal[1], normal[2]))\n",
    "            f.write(\"    outer loop\\n\")\n",
    "            for vertex in triangle:\n",
    "                f.write(\"      vertex {} {} {}\\n\".format(vertex[0], vertex[1], vertex[2]))\n",
    "            f.write(\"    endloop\\n\")\n",
    "            f.write(\"  endfacet\\n\")\n",
    "        f.write(\"endsolid GeneratedTriangles\\n\")\n",
    "\n",
    "def calculate_normal(vertex1, vertex2, vertex3):\n",
    "    # 计算三角形的法向量\n",
    "    normal = np.cross(np.array(vertex2) - np.array(vertex1), np.array(vertex3) - np.array(vertex1))\n",
    "    normal /= np.linalg.norm(normal)\n",
    "    return normal\n",
    "\n",
    "# 示例用法\n",
    "vertex1 = (0, 0, 0)\n",
    "vertex2 = (1, 0, 0)\n",
    "vertex3 = (0.5, 1, 0)\n",
    "num_triangles = 10  # 调整所需的三角形数量\n",
    "\n",
    "neighbouring_triangles = generate_neighbouring_triangles(vertex1, vertex2, vertex3, num_triangles)\n",
    "write_stl(neighbouring_triangles, \"../cst/generated_triangles2.stl\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "import numpy as np\n",
    "from stl import mesh\n",
    "\n",
    "# Function to generate a random point in 3D space\n",
    "def generate_random_point():\n",
    "    x = random.uniform(-10, 10)  # Adjust the range as needed\n",
    "    y = random.uniform(-10, 10)  # Adjust the range as needed\n",
    "    z = 0  # Set z=0 to keep the points in the XY plane\n",
    "    return (x, y, z)\n",
    "\n",
    "# Function to generate a triangle with adjacent sides\n",
    "def generate_triangle(initial_point):\n",
    "    point1 = initial_point\n",
    "    point2 = generate_random_point()\n",
    "    \n",
    "    # Ensure that the third point is adjacent to the first two\n",
    "    while True:\n",
    "        point3 = generate_random_point()\n",
    "        if is_adjacent(point1, point2, point3):\n",
    "            break\n",
    "    \n",
    "    return (point1, point2, point3)\n",
    "\n",
    "# Function to check if three points form adjacent sides\n",
    "def is_adjacent(point1, point2, point3):\n",
    "    # Calculate the distances between the points\n",
    "    dist12 = np.linalg.norm(np.array(point1) - np.array(point2))\n",
    "    dist13 = np.linalg.norm(np.array(point1) - np.array(point3))\n",
    "    dist23 = np.linalg.norm(np.array(point2) - np.array(point3))\n",
    "    \n",
    "    # Check if any two sides are adjacent\n",
    "    return dist12 + dist13 <= dist23 + 1e-8 or dist12 + dist23 <= dist13 + 1e-8 or dist13 + dist23 <= dist12 + 1e-8\n",
    "\n",
    "# Generate a list of triangles\n",
    "num_triangles = 10  # Number of triangles to generate\n",
    "triangles = []\n",
    "initial_point = generate_random_point()\n",
    "\n",
    "for _ in range(num_triangles):\n",
    "    triangle = generate_triangle(initial_point)\n",
    "    triangles.append(triangle)\n",
    "    initial_point = triangle[2]  # Use the last vertex as the initial point for the next triangle\n",
    "\n",
    "# Create the STL mesh\n",
    "vertices = np.array([vertex for triangle in triangles for vertex in triangle])\n",
    "faces = [[vertex_indices, [], []] for triangle in triangles for vertex_indices in [(0, 1, 2)]]\n",
    "\n",
    "# Write the STL file\n",
    "mesh_data = mesh.Mesh(np.zeros(len(faces), dtype=mesh.Mesh.dtype))\n",
    "for i, face in enumerate(faces):\n",
    "    face[0] = [vertices[face[0][0]], vertices[face[0][1]], vertices[face[0][2]]]\n",
    "    mesh_data.vectors[i] = face[0]\n",
    "\n",
    "mesh_data.save('../cst/triangles.stl')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "need at least one array to concatenate",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[2], line 33\u001b[0m\n\u001b[0;32m     30\u001b[0m dfs_generate_triangles(\u001b[38;5;241m3\u001b[39m, v1, v2, v3, triangles)\n\u001b[0;32m     32\u001b[0m \u001b[38;5;66;03m# Save the mesh to file \"triangles.stl\"\u001b[39;00m\n\u001b[1;32m---> 33\u001b[0m combined \u001b[38;5;241m=\u001b[39m mesh\u001b[38;5;241m.\u001b[39mMesh(\u001b[43mnumpy\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mconcatenate\u001b[49m\u001b[43m(\u001b[49m\u001b[43m[\u001b[49m\u001b[43mt\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdata\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mt\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mtriangles\u001b[49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m)\n\u001b[0;32m     34\u001b[0m combined\u001b[38;5;241m.\u001b[39msave(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mtriangles.stl\u001b[39m\u001b[38;5;124m'\u001b[39m)\n",
      "\u001b[1;31mValueError\u001b[0m: need at least one array to concatenate"
     ]
    }
   ],
   "source": [
    "import numpy\n",
    "from stl import mesh\n",
    "\n",
    "def generate_triangle(v1, v2, v3):\n",
    "    # Create the mesh\n",
    "    data = numpy.zeros(1, dtype=mesh.Mesh.dtype)\n",
    "\n",
    "    # Define the triangle\n",
    "    data['vectors'][0] = numpy.array([v1, v2, v3])\n",
    "\n",
    "    # Create the mesh object\n",
    "    m = mesh.Mesh(data)\n",
    "    return m\n",
    "\n",
    "def dfs_generate_triangles(depth, v1, v2, v3, triangles):\n",
    "    if depth == 0:\n",
    "        return\n",
    "    mid12 = (v1 + v2) / 2\n",
    "    mid23 = (v2 + v3) / 2\n",
    "    mid31 = (v3 + v1) / 2\n",
    "    dfs_generate_triangles(depth-1, v1, mid12, mid31, triangles)\n",
    "    dfs_generate_triangles(depth-1, v2, mid23, mid12, triangles)\n",
    "    dfs_generate_triangles(depth-1, v3, mid31, mid23, triangles)\n",
    "    dfs_generate_triangles(depth-1, mid12, mid23, mid31, triangles)  # new triangle in the center\n",
    "\n",
    "triangles = []\n",
    "v1 = numpy.array([0, 0, 0])\n",
    "v2 = numpy.array([1, 0, 0])\n",
    "v3 = numpy.array([0, 1, 0])\n",
    "dfs_generate_triangles(3, v1, v2, v3, triangles)\n",
    "\n",
    "# Save the mesh to file \"triangles.stl\"\n",
    "combined = mesh.Mesh(numpy.concatenate([t.data for t in triangles]))\n",
    "combined.save('triangles.stl')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from stl import mesh\n",
    "\n",
    "# Define the 8 vertices of the cube\n",
    "vertices = np.array([\\\n",
    "    [-1, -1, -1],\n",
    "    [+1, -1, -1],\n",
    "    [+1, +1, -1],\n",
    "    [-1, +1, -1],\n",
    "    [-1, -1, +1],\n",
    "    [+1, -1, +1],\n",
    "    [+1, +1, +1],\n",
    "    [-1, +1, +1]])\n",
    "# Define the 12 triangles composing the cube\n",
    "faces = np.array([\\\n",
    "    [0,3,1],\n",
    "    [1,3,2],\n",
    "    [0,4,7],\n",
    "    [0,7,3],\n",
    "    [4,5,6],\n",
    "    [4,6,7],\n",
    "    [5,1,2],\n",
    "    [5,2,6],\n",
    "    [2,3,6],\n",
    "    [3,7,6],\n",
    "    [0,1,5],\n",
    "    [0,5,4]])\n",
    "\n",
    "# Create the mesh\n",
    "cube = mesh.Mesh(np.zeros(faces.shape[0], dtype=mesh.Mesh.dtype))\n",
    "for i, f in enumerate(faces):\n",
    "    for j in range(3):\n",
    "        cube.vectors[i][j] = vertices[f[j],:]\n",
    "\n",
    "# Write the mesh to file \"cube.stl\"\n",
    "cube.save('../cst/cube.stl')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiwAAAGzCAYAAAAMr0ziAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAABtlElEQVR4nO3deXgUVdo28Lt6z77vhKxsIRskghEccWQTRVFQUBFExA0cMSqKIAj6ijP6Ke/MMMMiCK746jDqKLJFcEQCUSCyhAQCgbAknY2ks3Y63fX9AWkJWUiHdKqX+3ddfc306arqp46d7ps6VacEURRFEBEREdkwmdQFEBEREV0LAwsRERHZPAYWIiIisnkMLERERGTzGFiIiIjI5jGwEBERkc1jYCEiIiKbx8BCRERENo+BhYiIiGweAwsRddojjzyCyMhIqcvoFiNGjMCIESOkLsNMEAS89tprUpdBZLMYWIhs0Pr16yEIgvmhUCgQFhaGRx55BOfPn5e6PJtwZf909Ni1a5fUpRJRN1BIXQARtW/p0qWIiopCQ0MD9u7di/Xr12P37t04cuQINBqN1OVJ6qOPPmrx/MMPP8T27dtbtQ8YMKDN9bdt22a12oio+zGwENmw22+/HampqQCAxx57DP7+/vjzn/+Mb775Bvfff7/E1Ulr6tSpLZ7v3bsX27dvb9V+tbq6Ori6ukKlUlmzPCLqZhwSIrIjN998MwDg5MmT5rbGxkYsWrQIKSkp8PLygpubG26++Wbs3LmzxbqnT5+GIAh45513sHr1asTExECtVuOGG27AL7/80uq9vvrqK8THx0Oj0SA+Ph7//ve/26yptrYWzz//PMLDw6FWq9GvXz+88847uPpG8IIgYM6cOfjiiy8QFxcHFxcXpKWl4fDhwwCAVatWITY2FhqNBiNGjMDp06evp6sAXDpPJT4+Hvv378cf/vAHuLq64pVXXjG/duU5LNbqx+b9vbIfO3su0Pnz5/Hoo48iKCgIarUaAwcOxLp1666rT4jsFY+wENmR5h9xHx8fc5tOp8P777+PBx54ALNmzUJ1dTXWrl2LMWPGICsrC8nJyS228emnn6K6uhpPPPEEBEHAX/7yF9x77704deoUlEolgEvDJRMnTkRcXByWLVuG8vJyzJgxA7169WqxLVEUcdddd2Hnzp2YOXMmkpOTsXXrVrz44os4f/483nvvvRbL//TTT/jmm28we/ZsAMCyZctw5513Yt68efjHP/6Bp59+GhcvXsRf/vIXPProo/jhhx+uu8/Ky8tx++23Y8qUKZg6dSqCgoLaXM4a/fjdd99h8uTJSEhIwLJly3Dx4kXMnDkTYWFh16xbq9XixhtvNAe9gIAAfP/995g5cyZ0Oh3mzp17vV1DZF9EIrI5H3zwgQhA3LFjh1haWiqePXtW/PLLL8WAgABRrVaLZ8+eNS/b1NQk6vX6FutfvHhRDAoKEh999FFzW0FBgQhA9PPzEysqKsztX3/9tQhA/M9//mNuS05OFkNCQsTKykpz27Zt20QAYkREhLntq6++EgGIb7zxRov3nzRpkigIgpifn29uAyCq1WqxoKDA3LZq1SoRgBgcHCzqdDpz+/z580UALZa9ltmzZ4tXf6XdcsstIgBx5cqVrZa/5ZZbxFtuucX83Br9mJCQIPbq1Uusrq42t+3atatVP4ripf5ZvHix+fnMmTPFkJAQsaysrMVyU6ZMEb28vMS6urr2O4PIAXFIiMiGjRw5EgEBAQgPD8ekSZPg5uaGb775psWRDrlcbj4fw2QyoaKiAk1NTUhNTcWBAwdabXPy5MktjtA0DzOdOnUKAFBUVITs7GxMnz4dXl5e5uVGjRqFuLi4FtvavHkz5HI5/vSnP7Vof/755yGKIr7//vsW7bfddluLoZChQ4cCACZOnAgPD49W7c01XQ+1Wo0ZM2Zcc7nu7scLFy7g8OHDmDZtGtzd3c3L3XLLLUhISOiwFlEU8a9//Qvjx4+HKIooKyszP8aMGYOqqqo2ayJyZAwsRDZsxYoV2L59O7788kuMGzcOZWVlUKvVrZbbsGEDEhMTodFo4Ofnh4CAAHz33XeoqqpqtWzv3r1bPG/+0b148SIA4MyZMwCAPn36tFq3X79+LZ6fOXMGoaGhLcIG8PuVOc3bau+9mwNReHh4m+3NNV2PsLCwTp9ga41+jI2NbbVuW21XKi0tRWVlJVavXo2AgIAWj+bwVVJS0ql9InIUPIeFyIYNGTLEfJXQhAkTMHz4cDz44IPIy8sz/6v9448/xiOPPIIJEybgxRdfRGBgIORyOZYtW9bi5Nxmcrm8zfcSrzpJ1hrae29r1uTi4tKp5WypH00mE4BLV0JNnz69zWUSExOv+32I7AkDC5GdaP7xvPXWW/H3v/8dL7/8MgDgyy+/RHR0NDZt2gRBEMzLL168uEvvExERAQA4ceJEq9fy8vJaLbtjxw5UV1e3OMqSm5vbYlv2wFr9mJ+f3+q1ttquFBAQAA8PDxiNRowcObJL70/kaDgkRGRHRowYgSFDhmD58uVoaGgA8Pu/9K/8l/2+ffuQmZnZpfcICQlBcnIyNmzY0GIoZPv27cjJyWmx7Lhx42A0GvH3v/+9Rft7770HQRBw++23d6kGKXR3P4aGhiI+Ph4ffvghampqzO0//vij+VLujmqZOHEi/vWvf+HIkSOtXi8tLe1STUT2jEdYiOzMiy++iPvuuw/r16/Hk08+iTvvvBObNm3CPffcgzvuuAMFBQVYuXIl4uLiWvxQWmLZsmW44447MHz4cDz66KOoqKjA3/72NwwcOLDFNsePH49bb70VCxYswOnTp5GUlIRt27bh66+/xty5cxETE9Ndu2111ujHN998E3fffTeGDRuGGTNm4OLFi/j73/+O+Pj4a27zrbfews6dOzF06FDMmjULcXFxqKiowIEDB7Bjxw5UVFR0qSYie8UjLER25t5770VMTAzeeecdGI1GPPLII3jzzTfx22+/4U9/+hO2bt2Kjz/+2HzuS1eMHTsWX3zxBYxGI+bPn49Nmzbhgw8+aLVNmUyGb775BnPnzsW3336LuXPnIicnB2+//Tbefffd693VHmWNfhw/fjw+++wzNDY24uWXX8amTZuwfv169OvX75q3VggKCkJWVhZmzJiBTZs2Yc6cOfjf//1fVFRU4M9//nOXayKyV4LYE2faERGRWXJyMgICArB9+3apSyGyGzzCQkRkJQaDAU1NTS3adu3ahd9++63FbQGI6Np4hIWIyEpOnz6NkSNHYurUqQgNDUVubi5WrlwJLy8vHDlyBH5+flKXSGQ3eNItEZGV+Pj4ICUlBe+//z5KS0vh5uaGO+64A2+99RbDCpGFeISFiIiIbB7PYSEiIiKbx8BCRERENq9L57CsWLECb7/9NoqLi5GUlIS//e1vGDJkSJvLjhgxAj/++GOr9nHjxuG7774DcGlmycWLF2PNmjWorKzEsGHD8M9//rPNm6+1xWQy4cKFC/Dw8GgxpTYRERHZLlEUUV1djdDQUMhk1ziGIlpo48aNokqlEtetWycePXpUnDVrlujt7S1qtdo2ly8vLxeLiorMjyNHjohyuVz84IMPzMu89dZbopeXl/jVV1+Jv/32m3jXXXeJUVFRYn19fadqOnv2rAiADz744IMPPviww8fZs2ev+Vtv8Um3Q4cOxQ033GC+d4jJZEJ4eDieeeYZ883YOrJ8+XIsWrQIRUVFcHNzgyiKCA0NxfPPP48XXngBAFBVVYWgoCCsX78eU6ZMueY2q6qq4O3tjbNnz8LT07PNZQwGA7Zt24bRo0dDqVRasMeOw9n7wNn3H2AfAOwDZ99/gH0A2E4f6HQ6hIeHo7KyEl5eXh0ua9GQUGNjI/bv34/58+eb22QyGUaOHNnpG4StXbsWU6ZMgZubGwCgoKAAxcXFLe5I6uXlhaFDhyIzM7PNwKLX66HX683Pq6urAVy6jXx7t5JXKBRwdXWFi4uL035Anb0PnH3/AfYBwD5w9v0H2AeA7fSBwWAAgE6dzmFRYCkrK4PRaERQUFCL9qCgIPPt5DuSlZWFI0eOYO3atea24uJi8zau3mbza1dbtmwZlixZ0qp927ZtcHV17bAGToXNPnD2/QfYBwD7wNn3H2AfANL3QV1dXaeX7dGJ49auXYuEhIR2T9DtrPnz5yM9Pd38vPmQ0ujRozscEtq+fTtGjRrltIna2fvA2fcfYB8A7ANn33+AfQDYTh/odLpOL2tRYPH394dcLodWq23RrtVqERwc3OG6tbW12LhxI5YuXdqivXk9rVaLkJCQFttMTk5uc1tqtRpqtbpVu1KpvGbHd2YZR+fsfeDs+w+wDwD2gbPvP8A+AKTvA0ve26J5WFQqFVJSUpCRkWFuM5lMyMjIQFpaWofrfvHFF9Dr9Zg6dWqL9qioKAQHB7fYpk6nw759+665TSIiInIOFg8JpaenY/r06UhNTcWQIUOwfPly1NbWYsaMGQCAadOmISwsDMuWLWux3tq1azFhwoRW988QBAFz587FG2+8gT59+iAqKgqvvvoqQkNDMWHChK7vGRERETkMiwPL5MmTUVpaikWLFqG4uBjJycnYsmWL+aTZwsLCVpO/5OXlYffu3di2bVub25w3bx5qa2vx+OOPo7KyEsOHD8eWLVug0Wi6sEtERETkaLp00u2cOXMwZ86cNl/btWtXq7Z+/fqho+leBEHA0qVLW53fQkRERATwXkJERERkB3r0smYiIiIAMJpEZBVUoKS6AYEeGgyJ8oVcxnvBUfsYWIiIqEdtOVKEJf/JQVFVg7ktxEuDxePjMDY+pIM1yZlxSIiIiHrMliNFeOrjAy3CCgAUVzXgqY8PYMuRIokqI1vHwEJERD3CaBKx5D85aOsSjOa2Jf/JgdFk0T15yUkwsBARUY/IKqhodWTlSiKAoqoGZBVU9FxRZDcYWIiIqEeUVLcfVrqyHDkXBhYiIuoRgR6dmwy0s8uRc2FgISKiHjEw1BMqefuXLgu4dLXQkCjfniuK7AYDCxERWV1VvQGPfJCFRmPbJ9Q2x5jF4+M4Hwu1iYGFiIisqqK2EQ+9vxcHCivhplZg8rAo+LqrWyzj567CP6cO5jws1C5OHEdERFZTUt2Aqe/vw3FtDTxdlJh3TxIiAtwxbnBv5F2oxMbdp3BKW437U8MZVqhDPMJCRERWcaGyHpNX7cVxbQ183FR4ZVIyIgLcAQAymYABvXwwJrkXAGBbjlbKUskOMLAQEVG3Kyyvw/2rMlFQVgs/DzUWTBqEMF+3VsslR/lBLhOQX1KD/JIaCSole8HAQkRE3Sq/pAb3r8rEuYv1CPJywcJJgxDk7dLmsq5qBQaG+wAAth4t7skyyc4wsBARUbfJLdZh8upMFOsaEObrioX3JcPfs+N5VVJj/QEwsFDHGFiIiKhbHDpXiSmr9qK8phERAe54ZWIyvN3U11xvcJQ/BACHzlXhfGW99Qslu8TAQkRE1+3X0xV4aM0+VNYbEBPsgfn3JsHTVdWpdb3cVOgb6gUA2MajLNQOBhYiIroue/LL8PDaLFTrm9AvzAsv3ZMEN43Som00DwttOcLAQm1jYCEioi7bmVeCGet/Qb3BiITePnjx7kS4qCyf4isl5lJg+eV0Bcpr9N1dJjkABhYiIuqSLUeK8PiHv0LfZMLgaD88Nz4BaqW8S9sK8HRBZKA7TCKw4xjnZKHWGFiIiMhiX2efx+xPD8JgFDG0TwCeGTcQSsX1/aQ0H2XZepSBhVpjYCEiIot8/ksh5n6eDaNJxPABQXh6bBwU8uv/ObkhJgAAsPtEGaobDNe9PXIsDCxERNRp638uwEv/OgxRBG5LCMWsUf0h66a7K4f6uiLExwWNRhN25pV2yzbJcTCwEBFRp6z88SRe+08OAOD2Qb0w/dY+kAndE1YAQBAEpFw+ysJJ5OhqDCxERNQhURTx3vbjeOv7XADAhCEReODmGAjdGFaa3XD5PJZduSVoMBi7fftkvxhYiIioXaIoYtn3ufjfjBMAgPtuisLEtCirhBUAiArygK+7GrWNRvycX2aV9yD7xMBCRERtMplELPr6KFb/9xQAYOofYnHXDRFWfc9Lw0KcRI5aY2AhIqJWjCYRL/3rED7aewYCgEdv64sxg3r1yHvfcHnW2x3HtGgymnrkPcn2MbAQEVELBqMJcz/Pxhf7z0EQgCfG9Met8aE99v59Q73grlHgYp0BWacreux9ybYxsBARkZm+yYjZnxzAf367ALlMwJzb4zCsf3CP1iCXyTA4+vIkchwWossYWIiICABQ32jE4x/ux7YcLZRyGebeGY8hfQIlqSX1illvTSZRkhrItjCwEBERavRNmLE+Cz8eL4VaIcPzdyUgOcpPsnoG9vaBRilHsa4Bh85XSVYH2Q4GFiIiJ1dVb8DDa/dh76kKaFRyvDghEQN7+0hak0ohR1KULwBeLUSXMLAQETmxitpGPLhmLw4WVsJNrcD8e5LQL8xb6rIAAKlXzHorihwWcnYMLERETqqkugFTVmfi6AUdPF2UmD8xGdHBnlKXZZYU6QuFXEBBWS1OlNRIXQ5JjIGFiMgJFVU1YPKqvTiurYGPmwqvTEpGRIC71GW14KJSID780tAUrxaiLgWWFStWIDIyEhqNBkOHDkVWVlaHy1dWVmL27NkICQmBWq1G3759sXnzZvPrr732GgRBaPHo379/V0ojIqJrKGsAHnw/CwVltfD3UGPBpEEI83WTuqw2pcZeGhbawpshOj2FpSt8/vnnSE9Px8qVKzF06FAsX74cY8aMQV5eHgIDW1/+1tjYiFGjRiEwMBBffvklwsLCcObMGXh7e7dYbuDAgdixY8fvhSksLo2IiK7hZGkt/npUjqrGBgR5ueDle5Pg76mRuqx2DY72gyAARy/ocLaiDuG+rlKXRBKxOBW8++67mDVrFmbMmAEAWLlyJb777jusW7cOL7/8cqvl161bh4qKCuzZswdKpRIAEBkZ2boQhQLBwT07ORERkTM5VqTD1LW/oKpRQJivK16+Nwnebmqpy+qQh4sK/cO8cexcJbYeLcZjN0dLXRJJxKLA0tjYiP3792P+/PnmNplMhpEjRyIzM7PNdb755hukpaVh9uzZ+PrrrxEQEIAHH3wQL730EuRyuXm5EydOIDQ0FBqNBmlpaVi2bBl69+7d5jb1ej30er35uU6nAwAYDAYYDIY212lub+91Z+DsfeDs+w+wDwDn7YPD56vw6IYDqKw3IMxVxMt3DYCXRg7R2CR1adeUEuWLY+cqseVIEabfGH7d23PWz8CVbKUPLHl/QbTgWrELFy4gLCwMe/bsQVpamrl93rx5+PHHH7Fv375W6/Tv3x+nT5/GQw89hKeffhr5+fl4+umn8ac//QmLFy8GAHz//feoqalBv379UFRUhCVLluD8+fM4cuQIPDw8Wm3ztddew5IlS1q1f/rpp3B15eFCIqIrndIBq3LlaDAKiHAX8eQAI1ztaNT9oh547YACAkQsTTHCUyV1RdRd6urq8OCDD6Kqqgqenh1foWb1j6zJZEJgYCBWr14NuVyOlJQUnD9/Hm+//bY5sNx+++3m5RMTEzF06FBERETg//7v/zBz5sxW25w/fz7S09PNz3U6HcLDwzF69Oh2d9hgMGD79u0YNWqUeWjK2Th7Hzj7/gPsA8D5+iDzVDlWf3wQDUYT+oV64rnb+0Gfkwnv5OEQ5PaRWnwARJ/LxqmSGiAsEeNuuL67RjvbZ6AtttIHzSMknWHRp9Xf3x9yuRxarbZFu1arbff8k5CQECiVyhbDPwMGDEBxcTEaGxuhUrWOyt7e3ujbty/y8/Pb3KZarYZa3XrcValUXrPjO7OMo3P2PnD2/QfYB4Bz9MHO3BI88fFBNDaZkNDbB8/eGQ+VTIQegCBX2E1gAS5dLXSqpAbbc0vx8E1R3bJNZ/gMXIvUfWDJe1t0WbNKpUJKSgoyMjLMbSaTCRkZGS2GiK40bNgw5Ofnw2QymduOHz+OkJCQNsMKANTU1ODkyZMICQmxpDwiIrpsy5EiPP7Rr2hsMmFwtB+eG58AtVJ+7RVtVPPlzZkny1BV77znnjgzi+dhSU9Px5o1a7BhwwYcO3YMTz31FGpra81XDU2bNq3FSblPPfUUKioq8Oyzz+L48eP47rvv8Oabb2L27NnmZV544QX8+OOPOH36NPbs2YN77rkHcrkcDzzwQDfsIhGRc/k6+zxmf3oQBqOIoX0C8My4gVAq7Hue0BAfV4T5usJgFLEzt0TqckgCFh8PnDx5MkpLS7Fo0SIUFxcjOTkZW7ZsQVBQEACgsLAQMtnvfxjh4eHYunUrnnvuOSQmJiIsLAzPPvssXnrpJfMy586dwwMPPIDy8nIEBARg+PDh2Lt3LwICArphF4mInMfnvxTi5U2HIYrA8AFBmDWyP2QyQeqyukVKjD/OVxRi69FiTBgUJnU51MO6NIA5Z84czJkzp83Xdu3a1aotLS0Ne/fubXd7Gzdu7EoZRER0hfU/F+C1/+QAAG5LCMW0W/tAJjhGWAGAG2ID8M0vhdiVV4r6RiNcVPY7xEWWs+9jhEREBAD4566T5rBy+6BemO5gYQUAIgLc4e+hRr3BiP+eKJW6HOphDCxERHZMFEW8u/04/rwlFwAwYUgEHrg5BoKDhRUAEAQBKTGXThXYynsLOR0GFiIiOyWKIpZ9n4u/ZpwAANx/UxQmpkU5ZFhpdkOsPwBgR44WBqPpGkuTI2FgISKyQyaTiEVfH8Xq/54CAEy9JRbjb4iQuCrr6xPiBQ8XJXQNTdh3qkLqcqgHMbAQEdkZo0nES/86hI/2noEA4NHb+mJM8vXN/movZDIBKTGXjrJsOVokcTXUkxhYiIjsiMFowtzPs/HF/nOQCQKeGNMft8aHSl1Wj7rhcmDZdlQLk6nTt8MjO8fAQkRkJ/RNRjz9yQH857cLkMsEzLk9DsP6t31bFEcWF+4DF5UcJdV6HDxbKXU51EMYWIiI7EB9oxGzPtyP7TlaKOUyzL0zHjf0cc7JNRVyGZKj/ADwaiFnwsBCRGTjavRNmLE+C/89Xgq1Qobn70ow/2A7q9TLw0JbjxZDFDks5AwYWIiIbFhVvQEPr92HvacqoFHJ8eKERAzs7SN1WZJLjPCFUi7DmfI65BZXS10O9QAGFiIiG1VR24gH1+zFwcJKuKkVmH9PEvqFeUtdlk3QqBRIiLgU3LYc4bCQM2BgISKyQSXVDZiyOhNHL+jg6aLEKxOTER3sKXVZNiWVs946FQYWIiIbc6GyHpNX7cVxbQ183FRYMCkZvQPcpS7L5gyK9oNMEJBbXI0z5bVSl0NWxsBCRGRDCsvrcN/KTBSU1cLfQ40FkwYh1NdN6rJskrtGiQG9vADwKIszYGAhIrIR+SU1uG/VHpyvrEeQlwsWTBqEIG8Xqcuyac3DQjyPxfExsBAR2YBjRTpMXp0JrU6PMF9XLLwvGf6eGqnLsnnN0/QfKKyEVtcgcTVkTQwsREQSO3SuElNW70V5TSMiAtyxYFIyvN3UUpdlF3zc1Yi9fDLythytxNWQNTGwEBFJ6NfTFXhozT5U1RsQE+yB+fcmwcNFJXVZdiU19vIkchwWcmgMLEREEtmTX4aH12ahWt+E/mFeeOmeJLhplFKXZXeaZ73NPFWOyrpGiasha2FgISKSwM7cEjyy/hfUG4xI6O2DF+5OhItKIXVZdinI2xXhfm4wmkRkHCuRuhyyEgYWIqIetuVIER7/6Fc0NpkwONoPz41PgFopl7osu9Y8LLSFlzc7LAYWIqIe9HX2ecz+9CAMRhFD+wbgmXEDoVTwq/h6pVy+vPm/x0tR19gkcTVkDfwrISLqIRuzCjH382wYTSJuHhCMp8fEQSHn13B36O3vhkAvDfRNJvyYVyp1OWQF/EshIuoB638uwMubDkMUgdsSQvHYqH6QyQSpy3IYgiCY52ThsJBjYmAhIrKyf+46idf+kwMAuH1wL0y/tQ9kAsNKd2ue9faHYyVobDJJXA11NwYWIiIrEUUR724/jj9vyQUATBgSgQeGx0BgWLGK2BBPeLmqUK1vwp6TZVKXQ92MgYWIyApEUcSy73Px14wTAID7b4rCxLQohhUrkl0xLLT1KGe9dTQMLERE3cxkErHo66NY/d9TAICpt8Ri/A0RElflHJonkdueUwyjSZS4GupODCxERN3IaBIx71+H8NHeMxAAPHpbX4xJ7iV1WU5jQC9vuKoVKKtpxP4zF6Uuh7oRAwsRUTcxGE14duNBfLn/HGSCgCfG9Met8aFSl+VUFHIZBkX5AQC28mohh8LAQkTUDfRNRjz9yQF8e6gIcpmAObfHYVj/YKnLckrmWW+PFEMUOSzkKBhYiIiuU32jEbM+3I/tOVoo5TLMvTMeN/QJkLosp5XQ2xcqhQznK+tx9IJO6nKomzCwEBFdhxp9Ex75IAv/PV4KtUKG5+9KQPLlIQmShlopR2KELwAOCzkSBhYioi6qqjfg4bX7sK+gAhqVHC9OSMTA3j5Sl0VoOSxEjoGBhYioCypqG/Hgmr04WFgJN7UC8+9JQr8wb6nLosuSo/wglwk4UVKDk6U1UpdD3YCBhYjIQiW6BkxZnYmjF3TwdFHilYnJiA72lLosuoKbWom4cG8AHBZyFAwsREQWuFBZj8mr9+K4tgY+biosmJSM3gHuUpdFbWi+txBnvXUMXQosK1asQGRkJDQaDYYOHYqsrKwOl6+srMTs2bMREhICtVqNvn37YvPmzde1TSKinlZYXof7VmaioKwW/h5qLJg0CKG+blKXRe0YHO0HAcBvZytxobJe6nLoOlkcWD7//HOkp6dj8eLFOHDgAJKSkjBmzBiUlJS0uXxjYyNGjRqF06dP48svv0ReXh7WrFmDsLCwLm+TiKin5ZfU4L5Ve3C+sh5BXi5YeN8gBHm7SF0WdcDbTY0+IZeG6rZxWMjuWRxY3n33XcyaNQszZsxAXFwcVq5cCVdXV6xbt67N5detW4eKigp89dVXGDZsGCIjI3HLLbcgKSmpy9skIupJx4p0mLwqE1qdHmG+rlh4XzL8PDRSl0WdkBrLYSFHobBk4cbGRuzfvx/z5883t8lkMowcORKZmZltrvPNN98gLS0Ns2fPxtdff42AgAA8+OCDeOmllyCXy7u0Tb1eD71eb36u012aGMhgMMBgMLS5TnN7e687A2fvA2fff4B9AFjeB4fPV2HGhv2oqm9CRIAb5t0VDw+NHKKxyZplWk1z3fZav6VSonzw6U/AvoJyaCtr4eum4t8BbOe7wJL3tyiwlJWVwWg0IigoqEV7UFAQcnNz21zn1KlT+OGHH/DQQw9h8+bNyM/Px9NPPw2DwYDFixd3aZvLli3DkiVLWrVv27YNrq6uHe7D9u3bO3zdGTh7Hzj7/gPsA6BzfXBKB6zKlaPBKCDSXcQTkVVoyvkZjnBLvcrs3VKX0CMUAMJc5ThfJ2D5Fxm4MfD3qfr5dyB9H9TV1XV6WYsCS1eYTCYEBgZi9erVkMvlSElJwfnz5/H2229j8eLFXdrm/PnzkZ6ebn6u0+kQHh6O0aNHw9Oz7UsLDQYDtm/fjlGjRkGpVHbpfe2ds/eBs+8/wD4AOt8HmafKsfrjg2gwmtA/1BPP3RkHF5XVvzKtTjQ2oTJ7N7yTh0OQ2//+dMZQUyE27StEsSII48YN5t8BbOe7oHmEpDMs+rT6+/tDLpdDq205FqjVahEc3PZNvkJCQqBUKiGXy81tAwYMQHFxMRobG7u0TbVaDbVa3apdqVRes+M7s4yjc/Y+cPb9B9gHQMd9sDO3BE98fBCNTSYk9PbBs3fGQ62Ut7msvRLkCqcJLDf0CcKmfYX4Ob8CepMA9eX/7vw7kL4PLHlvi066ValUSElJQUZGhrnNZDIhIyMDaWlpba4zbNgw5Ofnw2QymduOHz+OkJAQqFSqLm2TiMhavj9chMc/+hWNTSYMjvbDc+MTHC6sOJswX1cEe7ug0WjCrjxefWqvLL5KKD09HWvWrMGGDRtw7NgxPPXUU6itrcWMGTMAANOmTWtxAu1TTz2FiooKPPvsszh+/Di+++47vPnmm5g9e3ant0lE1BO+Ongecz47CINRxNC+AXhm3EAoFZxf094JgoDUGN5byN5ZfDxw8uTJKC0txaJFi1BcXIzk5GRs2bLFfNJsYWEhZLLf/8DDw8OxdetWPPfcc0hMTERYWBieffZZvPTSS53eJhGRtW3MKsT8fx+GKAI3DwjGYyP7QSYTpC6LuklKbAC+3X8WO3NLoDcYpS6HuqBLA5hz5szBnDlz2nxt165drdrS0tKwd+/eLm+TiMiaPvi5AEv+kwMAuC0hFNNu7QOZwLDiSKKDPODjrsLFmkbsOVUhdTnUBTzWSURO7Z+7TprDyu2De2E6w4pDkgmC+d5C23J4Hos9YmAhIqckiiLe3X4cf95yab6nCUMi8MDwGAgMKw4r5fJ5LBm5JTCK11iYbI5zXNNGRHQFUQT+vPU41v58BgBw/01RGH9DhMRVkbX1D/OCu0aBi3UGnNIxmNobHmEhIqdiMon4skBmDitTb4llWHEScpkMg6IuHWU5VMHAYm8YWIjIaRhNIuZ/dRS7tTIIAGbe1hdjkntJXRb1oNTY3wOLKHJcyJ4wsBCRUzAYTXh240FsOngBMoh4YlRfjIgPlbos6mHxvX2gVspQ2Sjg8PnOTwtP0mNgISKHp28y4ulPDuDbQ0WQywRM72vCTf0CpS6LJKBSyJEU4QsA2H6MVwvZEwYWInJo9Y1GPLbhV2zP0UIpl2HuuAFI9uNQgDNLjfYDAGzL0V5jSbIlDCxE5LBq9E145IMs/HSiDGqFDM/flYCkSF+pyyKJJUX6QC6IOFVWh/ySaqnLoU5iYCEih1RVb8DDa/dhX0EFNCo55t2ThIG9faQui2yAi0qBfl6XjrLx3kL2g4GFiBxORW0jHlyzFwcLK+GmVmD+PUnoG+oldVlkQxJ9LweWowws9oKBhYgcSomuAVNWZ+LoBR08XZR4ZWIyooM9pS6LbEyCrwhBAI6c1+HcxTqpy6FOYGAhIodxobIek1fvxXFtDXzcVFgwKRm9A9ylLotskLsS6BdyKchuPcqTb+0BAwsROYTC8jrctzITBWW18PdQY8GkQQj1dZO6LLJhKTGXrhbaymEhu8DAQkR2L7+kBvet2oPzlfUI9nbBwvsGIcjbReqyyMalXL68+ZfTFSit1ktcDV0LAwsR2bVjRTpMXpUJrU6PMD9XLJiUDD8PjdRlkR3w99AgKtADogjsOMZhIVvHwEJEduvQuUpMWb0X5bWNiAhwx4KJyfB2U0tdFtmR1JhL9xbisJDtY2AhIrv06+kKPLRmH6rqDYgN9sT8iUnwcFFJXRbZmeabIf6cXwZdg0HiaqgjDCxEZHd+zi/Dw2uzUK1vQv8wL8y7JxFuaqXUZZEdCvV1Q6iPKwxGETtzeW8hW8bAQkR2ZWduCWas/wX1BiMSevvghbsT4aJSSF0W2bHmoywcFrJtDCxEZDe+P1yExz/6FY1NJgyO9sNz4xOgVsqlLovsXGpMAABgZ24pGgxGiauh9jCwEJFd+Orgecz57CAMRhFD+wbgmXEDoVTwK4yuX2SgO/w81Kg3GPHTiTKpy6F28K+diGzexqxCPPd/2TCaRNw8IBhPj4mDQs6vL+oegiCYrxbizRBtF//iicimffBzAV7edBiiCNyWGIrHRvWDTCZIXRY5mJTLw0IZuVoYjCaJq6G2MLAQkc36x658LPlPDgBg3OBwTB/RBzKBYYW6X79QL3i4KFFZZ0BWQYXU5VAbGFiIyOaIooh3t+XhL1vyAAAThkRgyvBoCAwrZCUymYCUaA4L2TIGFiKyKaIo4s3Nx/DXH/IBAJOHRWNiWhTDClldyuXzWLblFMNkEiWuhq7GwEJENsNkEvHq10ew5qcCAMDDt8TiztTeEldFzmJguA80Kjm0Oj2yz1VKXQ5dhYGFiGyC0SRi3r8O4eO9hRAAzLytL0Yn95K6LHIiSoUMyZGX7uDMSeRsDwMLEUnOYDTh2Y0H8eX+c5AJAp4YMwAj4kOlLouckHnW2yPFEEUOC9kSBhYikpS+yYinPzmAbw8VQS4TMGdcHIb1D5K6LHJSSRG+UMplOF1ehzxttdTl0BUYWIhIMvWNRjy24Vdsz9FCKZdh7p3xuCE2QOqyyIlpVArE9/YBAGw9opW4GroSAwsRSaJG34RHPsjCTyfKoFbI8PxdCUiO8pO6LCLzsNAWnsdiUxhYiKjHVdUb8PDafdhXUAEXlRzz7knCwMv/qiWS2qAof8gEAceKdCgsr5O6HLqMgYWIelRFbSMeXLMXBwsr4aZW4OV7k9A31EvqsojMPFyU6B926TPJq4VsBwMLEfWYEl0DJq/KxNELOni6KPHKxGREB3lKXRZRK6mXz6XisJDtYGAhoh5xobIek1fvxYmSGvi4qbBgUjJ6B7hLXRZRm5pnvT1QeBElugaJqyGgi4FlxYoViIyMhEajwdChQ5GVldXusuvXr4cgCC0eGo2mxTKPPPJIq2XGjh3bldKIyAadKa/FfSszUVBWC39PDRbeNwihvm5Sl0XULl93NWKCPSCKwLYcXi1kCywOLJ9//jnS09OxePFiHDhwAElJSRgzZgxKSkraXcfT0xNFRUXmx5kzZ1otM3bs2BbLfPbZZ5aWRkQ2KL+kBvevysT5ynoEe7tg4aRkBHq5SF0W0TWlxlwaFuJ5LLbB4sDy7rvvYtasWZgxYwbi4uKwcuVKuLq6Yt26de2uIwgCgoODzY+goNaTQqnV6hbL+PjwigEie3esSIfJqzKh1ekR5ueKBZOS4eehufaKRDageVgo82Q5quoMEldDCksWbmxsxP79+zF//nxzm0wmw8iRI5GZmdnuejU1NYiIiIDJZMLgwYPx5ptvYuDAgS2W2bVrFwIDA+Hj44M//vGPeOONN+Dn1/acDHq9Hnq93vxcp9MBAAwGAwyGtj9Uze3tve4MnL0PnH3/gZ7tg0PnqvDoh/tRVd+EiAA3zLsrHh4aOURjk9XfuyPN7y91HVJx9v0HOt8HwZ4q9PJ1xbmKOmw7egETkh3ndhG28n1oyfsLogU3S7hw4QLCwsKwZ88epKWlmdvnzZuHH3/8Efv27Wu1TmZmJk6cOIHExERUVVXhnXfewX//+18cPXoUvXpdurHZxo0b4erqiqioKJw8eRKvvPIK3N3dkZmZCblc3mqbr732GpYsWdKq/dNPP4Wrq2tnd4eIrOSkDliVK4feKCDSXcQTA4xwteifR0S2YXOhDFvPy5Doa8LMfiapy3E4dXV1ePDBB1FVVQVPz46vGLR6YLmawWDAgAED8MADD+D1119vc5lTp04hJiYGO3bswG233dbq9baOsISHh6OsrKzdHTYYDNi+fTtGjRoFpVJ5zTodkbP3gbPvP9AzfbDnZDme/OQg6g0mDAjzwtw7BsBFZTtpRTQ2oTJ7N7yTh0OQ205dPcXZ9x+wrA/OlNbg1c+zoVHKkPXyrXBRtf5HtD2yle9DnU4Hf3//TgUWiz6t/v7+kMvl0GpbnjGt1WoRHBzcqW0olUoMGjQI+fn57S4THR0Nf39/5OfntxlY1Go11Gp1m9u+Vsd3ZhlH5+x94Oz7D1ivD37I1eLJjw+iscmEhAgfPHtHPNRK2/yCF+QKp/3BBrj/QOf6ICLIC/6eGpTpGrCnoBJj4zv3W2cvpP4+tOS9LTrpVqVSISUlBRkZGeY2k8mEjIyMFkdcOmI0GnH48GGEhIS0u8y5c+dQXl7e4TJEZFu+P1yEJz7aj8YmEwZH++G5OxNsNqwQdZYgCLjh8sm3vFpIWhZfJZSeno41a9Zgw4YNOHbsGJ566inU1tZixowZAIBp06a1OCl36dKl2LZtG06dOoUDBw5g6tSpOHPmDB577DEAl07IffHFF7F3716cPn0aGRkZuPvuuxEbG4sxY8Z0024SkTV9dfA85nx2EAajiBv7BuKZcQOhVHBeSnIMzbPe7jimRWMTz2ORisXHAydPnozS0lIsWrQIxcXFSE5OxpYtW8yXKhcWFkIm+/2L6uLFi5g1axaKi4vh4+ODlJQU7NmzB3FxcQAAuVyOQ4cOYcOGDaisrERoaChGjx6N119/vc1hHyKyLZ9lFeKVfx+GKAJ/iAvGzNv6QSYTpC6LqNvEhnjCy1WJqjoD9p4qxx/6BkhdklPq0gDmnDlzMGfOnDZf27VrV4vn7733Ht577712t+Xi4oKtW7d2pQwiktgHPxdgyX9yAAC3JYZi2og+kAkMK+RYZIKAlGh//HCkCFuOFjOwSITHbImoS/6xK98cVsYNDsd0hhVyYCmXh4W2HdXCaOr0xbXUjRhYiMgioiji3W15+MuWPADAPUMjMGV4NASGFXJgcb284aqSo6xGj4OFF6UuxykxsBBRp4miiP/57hj++sOlaQkmD4vGvTdGMayQw1PIZRgUfelqoS1HeLWQFBhYiKhTTCYRr359BO/vLgAAPHxLLO5M7S1xVUQ9p/neQltzimHBnKvUTRhYiOiajCYR8/51CB/vLYQAYOZt/TA6uZfUZRH1qIQIX6gUMpytqEdOkU7qcpwOAwsRdchgNOHZjQfx5f5zkAkCnhwzACPiOakjOR+NUo6ECF8AwNaj2mssTd2NgYWI2qVvMuKpjw/g20NFkMsEzBkXh5v6B0ldFpFkUpuHhXgeS49jYCGiNtU3GvHYhl+x45gWSrkMc++Mxw2xnH+CnNugKD/IZQLytNUoKKuVuhynwsBCRK3U6Jsw/YMs/HSiDGqFDM/fnYDkKD+pyyKSnJtGiQG9vAHw3kI9jYGFiFqoqjdg6vv7kFVQAReVHPPuScLAcB+pyyKyGc3DQry8uWcxsBCRWUVtIx5csxfZZyvhrlHg5XuT0DfUS+qyiGxKSow/BADZZytRXNUgdTlOg4GFiAAAJboGTF6ViaMXdPB0UWL+vcmIDvKUuiwim+PtpkZsyKW/jW05PMrSUxhYiAjnK+tx/6pMnCipgY+bCgsmJaN3gLvUZRHZrNTLJ6BzWKjnMLAQObkz5bW4f2UmTpfXwd9Tg4X3DUKor5vUZRHZtObzWPYVVOBibaPE1TgHBhYiJ5ZfUoP7V2XifGU9gr1dsHBSMgK9XKQui8jmBXq5oLe/G4wmETuOcRK5nsDAQuSkci7oMHlVJrQ6PcL8XLFgUjL8PDRSl0VkN1JiLg0LcdbbnsHAQuSEDp2rwgNr9qK8thGRge5YMDEZ3m5qqcsisis3xF4aFvrviVLU6pskrsbxMbAQOZmTOmDa+l9RVW9AbIgnXr43CR4uKqnLIrI7vfzcEOTlgsYmE3bllUpdjsNjYCFyIntOlmPlMTlq9UYM6OWNlyYkwk2tlLosIrskCAJSLh9l4ay31sfAQuQkfsjVYtbHB9FoEpDQ2xvP35UAjUohdVlEdu2Gy1cL/ZBbAn2TUeJqHBsDC5ET+P5wEZ74aD8am0xI8DFh7h1xUCvlUpdFZPeigz3h7aZCjb4Je06WS12OQ2NgIXJw/z54DrM/PQCDUcSNffwxo68JSjn/9Im6g0wQkHL5KMtWTiJnVfzWInJgn2UVIv3/foNJBP4QF4wnR/UDswpR97rh8uXN23O0MJpEiatxXPzqInJQ63YXYP6mwxBFYGRiKGaO7AeZTJC6LCKH0y/MC25qBcprG/Hr6Qqpy3FYDCxEDmjFznws/TYHADBucDimjegDmcCwQmQNCrkMg6L9AABbeLWQ1TCwEDkQURTx/7bl4e2teQCAe4ZGYMrwaAgMK0RWlXp5WGjbUS1EkcNC1sDAQuQgRFHE/3x3DH/7IR8AMHlYNO69MYphhagHJET4QK2Q4XxlPY6c10ldjkNiYCFyACaTiIVfHcH7uwsAANNGxOLO1N4SV0XkPFQKORIjm4eFiiSuxjExsBDZOaNJxItfHsIn+wohAJh5Wz+MSuoldVlETie1+fJm3gzRKhhYiOyYwWjCsxsP4l8HzkEmCHhyzACMiA+Ruiwip5Qc5Qe5TEB+SQ3yS2qkLsfhMLAQ2akGgxFPfXwA3x4qglwmYM64ONzUP0jqsoiclqtagYHhPgB4byFrYGAhskP1jUbM+vBX7DimhVIuw9w743FDbIDUZRE5vVTeDNFqGFiI7EyNvgnTP8jCTyfKoFbK8fzdCUiO8pO6LCICMDjaHwKAQ+eqcL6yXupyHAoDC5EdqaozYOr7+5BVUAEXlRzzJiSaD0ETkfS8XFXoG+oFANjGoyzdioGFyE6U1+jxwJq9yD5bCXeNAi/fm2T+YiQi29E8LLSFN0PsVgwsRHagRNeAKav3IqdIB08XJV6ZmIzoIE+pyyKiNjTfvfmX0xUor9FLXI3jYGAhsnHnK+tx/6pMnCipgY+7CgvvG4Rwf3epyyKidgR4uiAy0B0mEdhxjHOydJcuBZYVK1YgMjISGo0GQ4cORVZWVrvLrl+/HoIgtHhoNJoWy4iiiEWLFiEkJAQuLi4YOXIkTpw40ZXSiBzKmfJa3L8yE6fL6+DvqcHCSYMQ4uMqdVlEdA3N9xbisFD3sTiwfP7550hPT8fixYtx4MABJCUlYcyYMSgpKWl3HU9PTxQVFZkfZ86cafH6X/7yF/z1r3/FypUrsW/fPri5uWHMmDFoaGiwfI+IHER+SQ3uX5WJ85X1CPZ2wcJJyQj0cpG6LCLqhOZZb3/OL0d1g0HiahyDxYHl3XffxaxZszBjxgzExcVh5cqVcHV1xbp169pdRxAEBAcHmx9BQb9PbiWKIpYvX46FCxfi7rvvRmJiIj788ENcuHABX331VZd2isje5VzQYfKqTGh1evTyc8OCScnw89Bce0Uisgmhvq4I8XFBo9GEnXmlUpfjEBSWLNzY2Ij9+/dj/vz55jaZTIaRI0ciMzOz3fVqamoQEREBk8mEwYMH480338TAgQMBAAUFBSguLsbIkSPNy3t5eWHo0KHIzMzElClTWm1Pr9dDr//9RCad7tKdMQ0GAwyGtpNsc3t7rzsDZ+8De9n/Q+eq8OiH+1FV34TIADe8eFc8PDRyiMam69528za6Y1v2ytn7wNn3H+i5PkiJ8sO3F89hy+ELuD3OtiZ2tJXvQ0ve36LAUlZWBqPR2OIICQAEBQUhNze3zXX69euHdevWITExEVVVVXjnnXdw00034ejRo+jVqxeKi4vN27h6m82vXW3ZsmVYsmRJq/Zt27bB1bXj8f3t27d3+LozcPY+sOX9P6kDVuXKoTcKiHQX8URkFZpyfsbFbn6fyuzd3bxF++PsfeDs+w9Yvw/6GgBAgR05xfj62/NQ2uBlLlJ/H9bV1XV6WYsCS1ekpaUhLS3N/Pymm27CgAEDsGrVKrz++utd2ub8+fORnp5ufq7T6RAeHo7Ro0fD07PtSz0NBgO2b9+OUaNGQalUdul97Z2z94Gt7//PJ8ux5pOD0BtNGBDmhefuiINGJe/W9xCNTajM3g3v5OEQ5Fb/87dJzt4Hzr7/QM/1gbcowrfgF1TUNMI9NhW39Q+02ntZyla+D5tHSDrDov9S/v7+kMvl0GpbXqal1WoRHBzcqW0olUoMGjQI+fn5AGBeT6vVIiTk97vMarVaJCcnt7kNtVoNtVrd5rav1fGdWcbROXsf2OL+/5CrxZMfH0RjkwmJEb549s6BUCm6N6xcSZArnPbHqpmz94Gz7z9g/T4QAKTEBGD7b+eRkVuGsQlhVnuvrpL6+9CS97boAJVKpUJKSgoyMjLMbSaTCRkZGS2OonTEaDTi8OHD5nASFRWF4ODgFtvU6XTYt29fp7dJZM++P1yEJz7aj8YmE1Ji/DH3znirhhUi6jk3XJ71dscxLZqMJomrsW8WR8v09HRMnz4dqampGDJkCJYvX47a2lrMmDEDADBt2jSEhYVh2bJlAIClS5fixhtvRGxsLCorK/H222/jzJkzeOyxxwBcuoJo7ty5eOONN9CnTx9ERUXh1VdfRWhoKCZMmNB9e0pkg/598Bye/7/fYBKBG/sG4onR/aGQ2+BANxF1Sd9QL7hrFLhYZ0DW6QrcdPlyZ7KcxYFl8uTJKC0txaJFi1BcXIzk5GRs2bLFfNJsYWEhZLLfv3AvXryIWbNmobi4GD4+PkhJScGePXsQFxdnXmbevHmora3F448/jsrKSgwfPhxbtmxpNcEckSP5dF8hFnx1GKII/CEuGDNv6weZTJC6LCLqRnKZDIOj/fHfnGJsPVLMwHIdujR4N2fOHMyZM6fN13bt2tXi+XvvvYf33nuvw+0JgoClS5di6dKlXSmHyO6s212Apd/mAABGJobi4RF9IBMYVogc0Q2xAZcCy1EtFo8fyH+YdBGPPRP1sBU7881hZVxKOKYxrBA5tLhwb2iUchTrGnDofJXU5dgtBhaiHiKKIv7ftjy8vTUPAHDP0AhMGRYNgWGFyKGpFHIkRfkC4L2FrgcDC1EPEEUR//PdMfzth0uX808eFo17b4xiWCFyEjdcvhni1qPFEEVR4mrsEwMLkZWZTCIWfnUE7+8uAABMGxGLO1N7S1wVEfWkxEhfKOUyFJTV4kRJjdTl2CUGFiIrajKa8OKXh/DJvkIIAGbe1g+jknpJXRYR9TAXlQIDe/sA4LBQVzGwEFmJwWjCs59n418HzkEmCHhyzACMiA+59opE5JBSL1/SvPUoA0tXMLAQWUGDwYinPj6A7w4VQS4T8My4ONzUP+jaKxKRwxoc7QdBAI5e0OFsRedv+keXMLAQdbP6RiNmffgrdhzTQimX4bnx8UiNta1byxNRz/NwUaF/mDcAHmXpCgYWom5Uo2/C9A+y8NOJMqiVcjx/dwKSIv2kLouIbASHhbqOgYWom1TVGTD1/X3IKqiAi0qOeRMSMTDcR+qyiMiGpFwOLL+euYjSar3E1dgXBhaiblBeo8cDa/Yi+2wl3DUKzL83GX1DvaQui4hsjJ+HBtFBHhBFYHuOVupy7AoDC9F1KtE1YMrqvcgp0sHTRYlXJiYjKshD6rKIyEY1Dwtt4bCQRRhYiK7D+cp63L8qEydKauDjrsLC+wYh3N9d6rKIyIY1n4SfebIMVfUGiauxHwwsRF10prwW96/MxOnyOvh7arBw0iCE+LhKXRYR2bgQH1eE+brCYBSxM7dE6nLsBgMLURfkl1TjvpWZOF9Zj2BvF7w6KRmBXi5Sl0VEdqL5KAtnve08BhYiC+Vc0GHyqr0oqdajl58bFkxKhq+HRuqyiMiONJ/H8uPxUtQ3GiWuxj4wsBBZIPtsJR5YsxfltY2IDHTHKxOT4e2mlrosIrIzEQHu8PdQo95gxH9PlEpdjl1gYCHqpF9OV2Dq+/tQVW9AbIgnXr43CR4uSqnLIiI7JAiCeViIk8h1DgMLUSfsPlGGaWuzUKNvwoBe3nhpQiLc1AwrRNR1zcNCO3K0MBhNEldj+xhYiK7hh1wtHt3wC+oNRiRG+OKFuxOgUSmkLouI7FyfEC94uiiha2jC3lPlUpdj8xhYiDqw+XARHv9wPxqbTEiJ8cfcO+OhUsilLouIHIBMJmAw7y3UaQwsRO3498FzmPPpATSZRNzYNxBzbo+DUsE/GSLqPjdcDizbjmphMokSV2Pb+O1L1IZP9xUi/f9+g0kE/hAXjKfGDIBCzj8XIupeceE+cFHJUVKtx8GzlVKXY9P4DUx0lXW7C/DKvw9DFIGRiaGYObIfZDJB6rKIyAEp5DIkR/kB4LDQtTCwEF1hxc58LP02BwAwLiUc00b0gUxgWCEi67kh5vdZb0WRw0LtYWAhAiCKIv7ftjy8vTUPAHDP0EhMGRYNgWGFiKwsIdIXSrkMhRV1yC2ulrocm8XAQk5PFEW88d0x/O2HfADA5GHRuPfGSIYVIuoRGqUcCRE+AHhvoY4wsJBTM5lELPzqCNbuLgAATBsRiztTe0tcFRE5mxs46+01MbCQ02oymvDil4fwyb5CCAAeG9kPo5J6SV0WETmh5Cg/yAQBucXVOF1WK3U5NomBhZySwWjCs59n418HzkEmCHhq7ADcMjBE6rKIyEm5a5QY0MsbAI+ytIeBhZyO3mDEUx/vx3eHiiCXCXhmXBzS+gVJXRYROblUznrbIQYWciqNRuCJT7Kx41gJlHIZnhsfb75jKhGRlFIuB5YDhZXQ6hokrsb2MLCQ06jRN2HlMTl+PlkOtVKOF+5OQFKkn9RlEREBAHzc1YgN8QQAbMvRSlyN7WFgIadQVWfAI+v342S1ABeVHPMmJCIu3EfqsoiIWjAPC/Hy5lYYWMjhldfo8cCavfjtXBVcFSJenpCAvqFeUpdFRNRKc2DJPFWOyrpGiauxLQws5NBKdA2Ysnovcop08HJV4pk4I6IC3aUui4ioTUHergj3c4PRJCLjWInU5dgUBhZyWOcr63H/qkycKKmBj7sKr9yTgFA3qasiIupYauyloyxbeLVQC10KLCtWrEBkZCQ0Gg2GDh2KrKysTq23ceNGCIKACRMmtGh/5JFHIAhCi8fYsWO7UhoRAOBMeS3uX5mJ0+V18PfUYOGkQQjxcZW6LCKia0q9fDPE/x4vRV1jk8TV2A6LA8vnn3+O9PR0LF68GAcOHEBSUhLGjBmDkpKOD12dPn0aL7zwAm6++eY2Xx87diyKiorMj88++8zS0ogAAPkl1bhvZSbOV9Yj2NsFr05KRqCXi9RlERF1Sri/GwK9NNA3mfBjXqnU5dgMiwPLu+++i1mzZmHGjBmIi4vDypUr4erqinXr1rW7jtFoxEMPPYQlS5YgOjq6zWXUajWCg4PNDx8fXsFBlsu5oMPkVXtRUq1HLz83LJw0CL4eGqnLIiLqNEEQzEdZOCz0O4UlCzc2NmL//v2YP3++uU0mk2HkyJHIzMxsd72lS5ciMDAQM2fOxE8//dTmMrt27UJgYCB8fHzwxz/+EW+88Qb8/NqeI0Ov10Ov15uf63Q6AIDBYIDBYGhzneb29l53Bo7eB7+dq8LMD/ejqr4JkQFuePGueHhoZBCNlw6pXv2/zoh9wD5w9v0H7KMPUqJ8sPnAWWQcK0FtvR4qRfeecmorvweWvL9FgaWsrAxGoxFBQS2nMQ8KCkJubm6b6+zevRtr165FdnZ2u9sdO3Ys7r33XkRFReHkyZN45ZVXcPvttyMzMxNyubzV8suWLcOSJUtatW/btg2urh2fp7B9+/YOX3cGjtgHJ3XAqlw59EYBke4inoisQlPOz7jYxrKV2bt7vD5bwz5gHzj7/gO23Qe+IuCplEOnb8LfPt+KAT6iVd5H6t+Durq6Ti9rUWCxVHV1NR5++GGsWbMG/v7+7S43ZcoU8/9PSEhAYmIiYmJisGvXLtx2222tlp8/fz7S09PNz3U6HcLDwzF69Gh4enq2+R4GgwHbt2/HqFGjoFQqr2Ov7Jej9sHPJ8ux5pOD0BtNGBDmhefuiING1TroisYmVGbvhnfycAhyq370bRb7gH3g7PsP2E8fpNbk44cjxbjo3hvjxg3s1m3byu9B8whJZ1j0X8rf3x9yuRxabcspg7VaLYKDg1stf/LkSZw+fRrjx483t5lMpktvrFAgLy8PMTExrdaLjo6Gv78/8vPz2wwsarUaarW6VbtSqbxmx3dmGUfnSH3wQ64WT358EI1NJiRG+OLZOwdCpWgdVq4kyBU2/SXVE9gH7ANn33/A9vsgNTYQPxwpRkZuKd68VwG5TOj295D698CS97ZoUEylUiElJQUZGRnmNpPJhIyMDKSlpbVavn///jh8+DCys7PNj7vuugu33norsrOzER4e3ub7nDt3DuXl5QgJCbGkPHIymw8X4fEP96OxyYTUGH/MvTP+mmGFiMheDOjlDVe1AmU1jdh/pq0BbudicbRMT0/H9OnTkZqaiiFDhmD58uWora3FjBkzAADTpk1DWFgYli1bBo1Gg/j4+Bbre3t7A4C5vaamBkuWLMHEiRMRHByMkydPYt68eYiNjcWYMWOuc/fIUW06cA4vfPEbTCKQ1jcQj4/uD4Wc8yASkeNQyGUYFOWHn3O12Hq0GEOifKUuSVIWB5bJkyejtLQUixYtQnFxMZKTk7FlyxbzibiFhYWQyTr/wyGXy3Ho0CFs2LABlZWVCA0NxejRo/H666+3OexD9Om+Qiz46jBEEfhDXDBm3tYPMiscKiUiklpqrD9+ztViy5FiLLxjAATBeb/rujR4N2fOHMyZM6fN13bt2tXhuuvXr2/x3MXFBVu3bu1KGeSE1u0uwNJvcwAAo5LCMPWWWMic+A+YiBxbQm9fqBUynK+sx9ELOsSHOe+NW3kMnezGip355rAyLiUcDzOsEJGDUyvlSIi4NBS01cknkWNgIZsniiLe2ZqHt7fmAQDuGRqJKcOinfrQKBE5j9TYy7PeHmFgIbJZoijije+O4e878wEAU4ZH494bIxlWiMhpJEf5Qi4TcKKkBidLa6QuRzIMLGSzTCYRC786grW7CwAA00bE4o6U3hJXRUTUs9zUSsSFewNw7mEhBhaySU1GE1748jd8sq8QAoDHRvbDqKReUpdFRCSJ5pshbnXiYSEGFrI5BqMJz36ejU0HzkMmCHhq7ADcMpCTCBKR80qJ9oeASzd5vVBZL3U5kmBgIZvSYDDiqY/347tDRZDLBDwzLg5p/YKuvSIRkQPzclOhT+ilS5q3OemwEAML2Yz6RiNmffgrdhwrgVIuQ/r4ePPZ8UREzi415tJNhLce1V5jScfEwEI2oUbfhOkfZOGnE2VQK+V44e4EJEb6SV0WEZHNSLkcWPYVlKOitlHianoeAwtJrqrOgIfe34esggq4qOSYNyERceE+UpdFRGRTAr1cEBHgDpMI7MhxvqMsDCwkqfIaPR5Ysxe/na2Eu0aB+fcmo2+o8049TUTUkd+HhZzvPBYGFpJMia4BU1bvRU6RDl6uKrwyMRlRQR5Sl0VEZLOaz+v76UQZavRNElfTsxhYSBLnK+tx/6pMnCipgY+7CgsmJSPc313qsoiIbFqYryuCvV3QaDRhV16J1OX0KAYW6nFnymtx/8pMnC6vg7+nBgsnDUKIj6vUZRER2TxBEMzDQs52byEGFupR+SXVuG9lJs5X1iPY2wWvTkpGoJeL1GUREdmN5mGhnbklaDAYJa6m5zCwUI/JuaDD5FV7UVKtRy8/NyycNAi+HhqpyyIisitRQR7wcVehttGIPSfLpC6nxzCwUI/IPluJKaszUV7biMhAd7wyMRlebiqpyyIisjsyQTDfW8iZhoUYWMjqsgoqMPX9fdA1NCE2xBMv35sEDxel1GUREdmt5knkdhwrQZPRJHE1PYOBhaxq94kyTFu3DzX6Jgzo5Y2XJiTCTc2wQkR0PfqHecFdo0BFbSN+OX1R6nJ6BAMLWU3GMS0e3fALGgwmJEb44oW7E6BRKaQui4jI7sllMgyOdq5J5BhYyCq+O1SEJz7aj8YmE1Jj/DH3znioFHKpyyIichgpV8x6K4qixNVYHwMLdbtNB87hmc8OoMkkIq1vIGbfHgelgh81IqLuFN/bB2qlDEVVDTh0rkrqcqyOvyLUrT7dV4jnv/gNJhH4Q1wwnhwzAAo5P2ZERN1NpZAj6fJd7Z1hWIi/JNRt1u4uwCv/PgxRBEYlhWHmyH6QyQSpyyIiclhXznrr6MNCDCzULVbszMfr3+YAAO5ICcfDt8RCJjCsEBFZU3KkHxRyAafKapFfUiN1OVbFwELXRRRFvLM1D29vzQMA3HtjJCYPi4bAsEJEZHUuagUGhvsAcPxhIQYW6jJRFPHGd8fw9535AIApw6Nxz9BIhhUioh5knvWWgYWoNZNJxMKvjmDt7gIAwLQRfXBHSm+JqyIicj6Do/0gCMCR8zqcu1gndTlWw8BCFmsymvDCl7/hk32FEAA8NrIfRiWFSV0WEZFT8nRVoV+oFwBg61GtxNVYDwMLWcRgNOHZjdnYdOA8ZIKAp8YOwC0DQ6Qui4jIqaXGXhoW2urAN0NkYKFOazAY8dTH+/Hd4SLIZQKeGReHtH5BUpdFROT0Ui5P0//LmQqUVuslrsY6GFioU+objZj14a/YcawESrkM6ePjzYmeiIik5e+pQVSgB0QR2HHMMYeFGFjommr0TZi+Lgs/nSiDWinHC3cnIPHy7IpERGQbUmMc+2aIDCzUoao6Ax56fx+yTlfARSXHvAmJiLt8zT8REdmO1NhLgeXn/DLoGgwSV9P9GFioXeU1ejywZi9+O1sJd40C8+9NRt/LZ6ITEZFtCfV1Q6ivKwxGETtzS6Qup9sxsFCbSnQNmLx6L3KKdPByVeGVicmICvKQuiwiIuqAIw8LMbBQK+cr63H/qkzkl9TAx12FBZOSEe7vLnVZRER0Dc2z3u7MLUWDwShxNd2rS4FlxYoViIyMhEajwdChQ5GVldWp9TZu3AhBEDBhwoQW7aIoYtGiRQgJCYGLiwtGjhyJEydOdKU0uk6ny2px/8pMnC6vQ4CnBgsnDUKIj6vUZRERUSdEBrrDz0ONeoMRP50ok7qcbmVxYPn888+Rnp6OxYsX48CBA0hKSsKYMWNQUtLxeNnp06fxwgsv4Oabb2712l/+8hf89a9/xcqVK7Fv3z64ublhzJgxaGhosLQ8ug75JdW4f1UmzlfWI9jbBQsnJSPQy0XqsoiIqJMEQTAPC21xsEnkLA4s7777LmbNmoUZM2YgLi4OK1euhKurK9atW9fuOkajEQ899BCWLFmC6OjoFq+Joojly5dj4cKFuPvuu5GYmIgPP/wQFy5cwFdffWXxDlHX5FzQYfKqvSip1qOXnxsWThoEXw+N1GUREZGFmufI2nFMC4PRJHE13UdhycKNjY3Yv38/5s+fb26TyWQYOXIkMjMz211v6dKlCAwMxMyZM/HTTz+1eK2goADFxcUYOXKkuc3LywtDhw5FZmYmpkyZ0mp7er0eev3vM/npdDoAgMFggMHQ9qVcze3tve4M2uuD385V4dEN+6FraEJkgDtevGsgPDQyiMYmKcq0mub9cbT9sgT7gH3g7PsPOH4f9Al0g4eLElX1Buw5UYKbYlrPm2Urv4mWvL9FgaWsrAxGoxFBQS2nYw8KCkJubm6b6+zevRtr165FdnZ2m68XFxebt3H1Nptfu9qyZcuwZMmSVu3btm2Dq2vH51ts3769w9edwZV9cFIHrMqVQ28UEOUh4onISjTl/IyLEtZnbZXZu6UuQXLsA/aBs+8/4Nh9EO8hQ2a9DGu+/wWV0e0fZZH6N7GurvN3l7YosFiquroaDz/8MNasWQN/f/9u2+78+fORnp5ufq7T6RAeHo7Ro0fD09OzzXUMBgO2b9+OUaNGQalUdlst9uTqPvj5ZDlWf3IQeqMJA8K88NwdcdCo5FKXaTWisQmV2bvhnTwcgtyqH32bxT5gHzj7/gPO0Qc3+VUg89scnKhzwdixf4BMJrR43VZ+E5tHSDrDov9S/v7+kMvl0Gpb3qdAq9UiODi41fInT57E6dOnMX78eHObyXQp6SkUCuTl5ZnX02q1CAn5/a6/Wq0WycnJbdahVquhVqtbtSuVymt2fGeWcXRKpRL/za/AU58cRGOTCYkRvnj2zoFQKRw3rFxJkCsc9kuqs9gH7ANn33/AsftgYIQ/NCo5tNV6HNXWYnDvtmcol/o30ZL3tuikW5VKhZSUFGRkZJjbTCYTMjIykJaW1mr5/v374/Dhw8jOzjY/7rrrLtx6663Izs5GeHg4oqKiEBwc3GKbOp0O+/bta3ObdP2+P1KMJz7aj8YmE1Jj/DH3zninCStERM5AqZBh0OV7vm11kKuFLI6W6enpmD59OlJTUzFkyBAsX74ctbW1mDFjBgBg2rRpCAsLw7Jly6DRaBAfH99ifW9vbwBo0T537ly88cYb6NOnD6KiovDqq68iNDS01XwtdP1+KRXw6d5DMIlAWt9APD66PxRyzh9IRORoUmL9kXm8BFuPFuPl2/tDEIRrr2TDLA4skydPRmlpKRYtWoTi4mIkJydjy5Yt5pNmCwsLIZNZ9gM4b9481NbW4vHHH0dlZSWGDx+OLVu2QKPhZbXdaeMv5/BJvgwigFsGBuPRP/ZrNa5JRESOISnCF0q5DKfL65CnrUb/4LbP8bQXXRq8mzNnDubMmdPma7t27epw3fXr17dqEwQBS5cuxdKlS7tSDnXC2t0FeP3bHAACRiWGYOqIvpDZedomIqL2aVQKxPf2wcGCcmw9orX7wMKxACewYmf+5bAC3BZqwtSboxlWiIicQGrs5VlvHeBmiAwsDkwURbyzNQ9vb80DANw7pDfG9zbZ/TgmERF1zqAof8gEAceKdCgs7/ycJ7aIgcVBiaKI1789hr/vzAcATBkejQlDeoNZhYjIeXi4KNE/zAsAsNXOj7IwsDggk0nEgq+OYN3PBQCAaSP64I6U3hJXRUREUmi+t5C9DwsxsDiYJqMJL3z5Gz7dVwgBwGMj+2FUUpjUZRERkURSLt+9+UDhRZToGiSupusYWBxIY5MJz27MxqYD5yETBDw1dgBuGRhy7RWJiMhh+bqrERPsAVEEtuVor72CjWJgcRANBiOe/mQ/vjtcBLlMwDN3xCGtX9C1VyQiIoeXGnNpWMiez2NhYHEA9Y1GzPrwV+w4VgKlXIb08fHmDycREVHq5WGhzJPlqKozSFxN1zCw2LnqBgOmr8vCTyfKoFbK8eKEBCRevn8EERERAAT7uKKXnxuaTCIycu1zWIiBxY5V1RkwdW0Wsk5XwEUlx0v3JGJAr7bvyElERM6t+SiLvQ4LMbDYqfIaPR5Ysxe/na2Eu0aB+fcmo0+Il9RlERGRjWqe9fbH46Woa2ySuBrLMbDYIa2uAZNX70VOkQ5eriq8MjEZUUEeUpdFREQ2rLe/OwI8NWgwmPDTiXKpy7EYA4udOXexDvevykR+SQ183dVYMCkZ4f7uUpdFREQ2ThAE87DQ9mMlEldjOQYWO3K6rBaTV+3FmfI6BHhqsGBSMkJ8XKUui4iI7ETzrLc/5JWiySRxMRZSSF0Adc4JbTUeen8fSqr1CPZ2wfx7k+DroZG6LCIisiOxIZ7wclWhqq4R+Tr7urkcj7DYgaMXqjB59V6UVOsR7ueGhZMGMawQEZHFZIKAlOhLU1/8VsHAQt0o+2wlHli9FxW1jYgKdMf8icnwclNJXRYREdmp5mGhwxUCjCZR4mo6j4HFhmUVVGDq+/uga2hCnxBPvHxvMjxclFKXRUREdmxAL2+4quSoNgjIPlspdTmdxsBio346UYpp6/ahRt+EuF7emDchEa5qnnJERETXRyGXITnKFwCwLcd+rhZiYLFBO3K0mLn+VzQYTEiM8MXzdydAo2JYISKi7pF6+TyWbcdKIIr2MSzEwGJjvjtUhCc/3o9GowmpMf6Ye2c8VAq51GUREZEDSejtA6VMxLmL9cgp0kldTqcwsNiQf+0/h2c+O4Amk4i0foGYMy4OSgX/ExERUfdSK+UY4H3pyMrWI/ZxbyH+GtqIT/adwfNf/AaTCNwyMBhPjh4AuYz/eYiIyDoSfS8HlqP2cfdm/iLagLW7C7Dg30cAAKOSwvDobf0gk9nX9fFERGRfBvqIkMsE5GmrUVBWK3U518TAIrG//3ACr3+bAwC4MyUcD98SC5nAsEJERNblqgAGhHkBALYetf1hIQYWiYiiiLe35uKdbccBAPfeGIn7h0VDYFghIqIekhpz6WqhLXZwHgsDiwREUcTr3x7Dip0nAQBThkfjnqGRDCtERNSjBkf5QcClWdWLqxqkLqdDDCw9zGQSseCrI1j3cwEAYPqIPrgjpbfEVRERkTPydlMhNsQTALAtx7aPsjCw9KAmowkvfPEbPt1XCAHArJH9MDIpTOqyiIjIiTXfW8jWh4UYWHpIY5MJz27MxqaD5yETBDw1dgD+MDBE6rKIiMjJpcb4AwD2FVTgYm2jxNW0j4GlBzQYjHjq4/347nARFHIBz9wRh7R+QVKXRUREhEAvF/T2d4PRJGLHMdudk4WBxcrqGpvw2IZfkZFbAqVchufujEdqTIDUZREREZk1DwvZ8uXNDCxWVN1gwCPrfsHu/DKolXK8OCEBiZF+UpdFRETUQvOw0H9PlKFW3yRxNW1jYLGSyrpGTF2bhazTFXBVKfDSPYkY0MtH6rKIiIha6eXnhiAvFzQ2mbArr1TqctrEwGIF5TV6PLBmH347Wwl3jRLzJyahT4iX1GURERG1SRAEpMZeOspiq8NCDCzdTKtrwOTVe3GsSAcvVxVemZiEyEAPqcsiIiLqUPOw0A+5JdA3GSWupjUGlm507mId7l+VifySGvi6q7FgUjLC/d2lLouIiOiaooM94eOmQo2+CXvyy6Uup5UuBZYVK1YgMjISGo0GQ4cORVZWVrvLbtq0CampqfD29oabmxuSk5Px0UcftVjmkUcegSAILR5jx47tSmmSOV1Wi/tXZuJMeR0CPDVYMCkZIT6uUpdFRETUKTJBwOAY2x0WsjiwfP7550hPT8fixYtx4MABJCUlYcyYMSgpKWlzeV9fXyxYsACZmZk4dOgQZsyYgRkzZmDr1q0tlhs7diyKiorMj88++6xreySBE9pq3L8qExeqGhDs7YKFk5IR6OUidVlEREQWueHytBvbc7QwmkSJq2nJ4sDy7rvvYtasWZgxYwbi4uKwcuVKuLq6Yt26dW0uP2LECNxzzz0YMGAAYmJi8OyzzyIxMRG7d+9usZxarUZwcLD54eNjH1fUHL1Qhcmr96KkWo9wPzcsnDQIvh4aqcsiIiKyWL8wL7hrFCivbcSvpyukLqcFhSULNzY2Yv/+/Zg/f765TSaTYeTIkcjMzLzm+qIo4ocffkBeXh7+/Oc/t3ht165dCAwMhI+PD/74xz/ijTfegJ9f23OW6PV66PV683OdTgcAMBgMMBgMba7T3N7e612RfbYSMz88AF1DE6IC3fHC+IHw0MggGm3zGvbmumy1Pmtz9v0H2AcA+8DZ9x9gHwDt94EcQHKkL3bnlmDz4QsYHO5p1Tos+U0WRFHs9DGfCxcuICwsDHv27EFaWpq5fd68efjxxx+xb9++NterqqpCWFgY9Ho95HI5/vGPf+DRRx81v75x40a4uroiKioKJ0+exCuvvAJ3d3dkZmZCLpe32t5rr72GJUuWtGr/9NNP4eraM+eN5OuA1cfk0JsERHmIeKK/ES4WxT8iIiLbc7hCwPt5cvioRCwebIQgWO+96urq8OCDD6Kqqgqenh2Hox75ifXw8EB2djZqamqQkZGB9PR0REdHY8SIEQCAKVOmmJdNSEhAYmIiYmJisGvXLtx2222ttjd//nykp6ebn+t0OoSHh2P06NHt7rDBYMD27dsxatQoKJXK69qf3fnlWPPpQehNJsT18sLccXHQqFoHK1sjGptQmb0b3snDIcidL105+/4D7AOAfeDs+w+wD4CO++DGJiM+OrUPFxtNiEgejvgw6x1laR4h6QyL/kv5+/tDLpdDq215cyStVovg4OB215PJZIiNjQUAJCcn49ixY1i2bJk5sFwtOjoa/v7+yM/PbzOwqNVqqNXqVu1KpfKaYaQzy3RkR44WT39yEI1GE5IiffGnOwZCpbD9sHIlQa5w2j9SgPsPsA8A9oGz7z/APgDa7gO1XIHECD/8kl+KHXmlGGTFW8pY8nts0Um3KpUKKSkpyMjIMLeZTCZkZGS0GCK6FpPJ1OIclKudO3cO5eXlCAkJsaS8btfYZMLan05h0ddHsPanU/j6wHk8+fF+NBpNSI3xx9w74+0urBAREV3LDeZZb23n7s0WR8v09HRMnz4dqampGDJkCJYvX47a2lrMmDEDADBt2jSEhYVh2bJlAIBly5YhNTUVMTEx0Ov12Lx5Mz766CP885//BADU1NRgyZIlmDhxIoKDg3Hy5EnMmzcPsbGxGDNmTDfuqmWWbc7Bmp8K0NZVXWn9AvHE6P6QyzjvHhEROZ6kSD/IZQLyS2qQX1KNWBuYsd3iwDJ58mSUlpZi0aJFKC4uRnJyMrZs2YKgoCAAQGFhIWRX/JDX1tbi6aefxrlz5+Di4oL+/fvj448/xuTJkwEAcrkchw4dwoYNG1BZWYnQ0FCMHj0ar7/+epvDPj1h2eYcrPpvQbuve7uqGFaIiMhhuaoVGBjug0NnKrD1qNY+AwsAzJkzB3PmzGnztV27drV4/sYbb+CNN95od1suLi6tJpGTUmOTCWt+aj+sAMD3B8/BTaOASiGHTBAgk+Hy/wqQX/5fQRAglwmQCYBMJlx63dx27XXkl5+3Wkd2VZsgQBAu3biKiIiou6TG+l8OLMWYfWus1OX0zFVC9uSjzNNtDgNd7cvM01avxRItQs4VIejKcCQXBIiNcihy90Muk3VuHVlzKGojgF1jnd+DWtfWkV8Z4lq83s46Mly17ZbrCCYTOn8RPxGRcxsc7Y8PMo7j0LkqnK+sR5i3tDO4M7Bc5UxFXaeWi/Z3Q2IvLzSZRJhEEUbT74+22owmEUZRhNEEGE2mFm0mE9BkMsFoAkyiiCajCSbxUpvJhMvrdfxLaxIBk1EEcK1fZAFoqO9cZzgkBYS9uzsdcq48knX1OkKr8NXJdVq93sY65m3jirDYzjqtwiBatl8Z9GBCdT1gqGqAXKFod53fgyqP3hE5Ky9XFfqGeSHvfBVW/3gSgyN8EOihwZAoX8hlPf+9wMBylQjfzk0899DQ3ph5c7SVq/mdKIqtQ4xRNIcZcyC6uu2K1xobDdi9Zw+GDL0Rgkx+KVhdDljGyyHryjbT5fXM/79F8GorjLVuu3JbTe20NYe7K9+zM9tvrtd41baaTGKHR1JE4NI2IAK2dwf1HqAAsn/t9NJXHyH7PdC0E3LaCYHtrSN0EBy7c53m2mSiiLqLArwKL0KmULRc5+rh26vaWw/Vtu4bIkcS6KVB3vkqbMg8gw2ZZwAAIV4aLB4fh7HxPXslLwPLVR5Oi8T/bD7W4bCQTLi0XE8SBAFyAZDLun4ZtcFgQNERYGiU73VPnmfrxCtD0OUQo9cbsG37doz4422QyeWdC12dCUuiiCZjy8B39Xtfart8dK3FkbaO2nA5iF1x9M0czn4Prm2FzPb3wQR9owGCTA6jCPPrHen80Tt7Igdyj3b7VgXA4pDT1hBp6/PeOr/O70fj2lkHJjQUCXD77QLkl8/Da+vcutbDrmixPx2dj9eZ4dvmoWayXb/kl+KnnNaXNRdXNeCpjw/gn1MH92hoYWC5ikohw6ybozq8SmjWzVFQKXiVkC0TBAEKuYArp8kxyAF3JRDooXb4wNYeg8GAzZs3Y9y4MS36oL2jXZ0e8mwvJF11xK853LU40nZF4LvWe3fp6NtVgdJoNKGisgru7h4wAS2DXgdHKJuHbjvKd78fvQNgtOWAJwdOn5K6CAhtDqF2EHJahbLWQ6Qtz3trZx1BhKFUBpe6U5DLZFcN73bufa4Og8LV5+Nda53Lr7U55NvO0cOeZDKJ+PjH/DZfE3EpnC/5Tw5GxQX32PAQA0sb5o+LA4BW87DIhEthpfl1IkchkwlQSTAmLYXfQ9tNXQquzUfvWoSY5vPQrmq7FH4uHSHrbFvLIHb56NoVQ6pG45VH3ywImZfXNzQZcfbceQSHhMAkCu0GyqvbWmyznba2hqk7HJ4VgSbJjt7JAO0FCd6369oMOVcEuo6GSFuvAxh1MqgvHIVcLmu1TlVdIypq2p/gVQRQVNWArIIKpMVYbybcKzGwtGP+uDg8P7o/Pso8jTMVdYjwdcXDaZE8skLk5MxH78wt9jXb9aXAdhbjxiX1yJHGVsOUbZ3bdvXwaTvDrOaw1EZbR+fQXd3WaDAi7/gJRMXEQBSEdodUf2+76mKJq9p+D6y/D+uah26vPPewvSOHV7xvR8xH77ot4MmAqovXtYWS6oZuquXaGFg6oFLIevTEWiIiR3PpvBkBShvKdQaDAZsb8jBuVB+bGh5uvriivSB29YURbQ55tndU7KqwpDc04WB2NgbGJ0KQyVq9z8nSGnyWdfaaNQd6aHqgZy5hYCEiIrIBv19cYf3hWYPBAOX5gxiXEtZmaDOaROzKK0VxVUObx3MEAMFely5x7ikc3yAiIqIW5DIBi8dfOl/z6vjU/Hzx+LgenY+FgYWIiIhaGRsfgn9OHYxgr5bDPsFemh6/pBngkBARERG1Y2x8CEbFBSOroAIl1Q2c6ZaIiIhsk1wm9Nilyx3hkBARERHZPAYWIiIisnkMLERERGTzGFiIiIjI5jGwEBERkc1jYCEiIiKbx8BCRERENo+BhYiIiGweAwsRERHZPIeY6VYUL91LUqfTtbuMwWBAXV0ddDqdTd1OvCc5ex84+/4D7AOAfeDs+w+wDwDb6YPm3+3m3/GOOERgqa6uBgCEh4dLXAkRERFZqrq6Gl5eXh0uI4idiTU2zmQy4cKFC/Dw8IAgtH1DJp1Oh/DwcJw9exaenp49XKFtcPY+cPb9B9gHAPvA2fcfYB8AttMHoiiiuroaoaGhkMk6PkvFIY6wyGQy9OrVq1PLenp6Ou0HtJmz94Gz7z/APgDYB86+/wD7ALCNPrjWkZVmPOmWiIiIbB4DCxEREdk8pwksarUaixcvhlqtlroUyTh7Hzj7/gPsA4B94Oz7D7APAPvsA4c46ZaIiIgcm9McYSEiIiL7xcBCRERENo+BhYiIiGweAwsRERHZPAYWIiIisnkOFVhWrFiByMhIaDQaDB06FFlZWe0ue/ToUUycOBGRkZEQBAHLly/vuUKtyJI+WLNmDW6++Wb4+PjAx8cHI0eO7HB5e2DJ/m/atAmpqanw9vaGm5sbkpOT8dFHH/VgtdZhSR9caePGjRAEARMmTLBugT3Akj5Yv349BEFo8dBoND1Ybfez9DNQWVmJ2bNnIyQkBGq1Gn379sXmzZt7qFrrsKQPRowY0eozIAgC7rjjjh6suPtZ+jlYvnw5+vXrBxcXF4SHh+O5555DQ0NDD1XbCaKD2Lhxo6hSqcR169aJR48eFWfNmiV6e3uLWq22zeWzsrLEF154Qfzss8/E4OBg8b333uvZgq3A0j548MEHxRUrVogHDx4Ujx07Jj7yyCOil5eXeO7cuR6uvHtYuv87d+4UN23aJObk5Ij5+fni8uXLRblcLm7ZsqWHK+8+lvZBs4KCAjEsLEy8+eabxbvvvrtnirUSS/vggw8+ED09PcWioiLzo7i4uIer7j6W7r9erxdTU1PFcePGibt37xYLCgrEXbt2idnZ2T1cefextA/Ky8tb/Pc/cuSIKJfLxQ8++KBnC+9GlvbBJ598IqrVavGTTz4RCwoKxK1bt4ohISHic88918OVt89hAsuQIUPE2bNnm58bjUYxNDRUXLZs2TXXjYiIcIjAcj19IIqi2NTUJHp4eIgbNmywVolWdb37L4qiOGjQIHHhwoXWKK9HdKUPmpqaxJtuukl8//33xenTp9t9YLG0Dz744APRy8urh6qzPkv3/5///KcYHR0tNjY29lSJVne93wXvvfee6OHhIdbU1FirRKuztA9mz54t/vGPf2zRlp6eLg4bNsyqdVrCIYaEGhsbsX//fowcOdLcJpPJMHLkSGRmZkpYWc/pjj6oq6uDwWCAr6+vtcq0muvdf1EUkZGRgby8PPzhD3+wZqlW09U+WLp0KQIDAzFz5syeKNOqutoHNTU1iIiIQHh4OO6++24cPXq0J8rtdl3Z/2+++QZpaWmYPXs2goKCEB8fjzfffBNGo7Gnyu5W3fFduHbtWkyZMgVubm7WKtOqutIHN910E/bv328eNjp16hQ2b96McePG9UjNneEQd2suKyuD0WhEUFBQi/agoCDk5uZKVFXP6o4+eOmllxAaGtriQ24vurr/VVVVCAsLg16vh1wuxz/+8Q+MGjXK2uVaRVf6YPfu3Vi7di2ys7N7oELr60of9OvXD+vWrUNiYiKqqqrwzjvv4KabbsLRo0c7fRd4W9GV/T916hR++OEHPPTQQ9i8eTPy8/Px9NNPw2AwYPHixT1Rdre63u/CrKwsHDlyBGvXrrVWiVbXlT548MEHUVZWhuHDh0MURTQ1NeHJJ5/EK6+80hMld4pDBBa6fm+99RY2btyIXbt22f0Jh5bw8PBAdnY2ampqkJGRgfT0dERHR2PEiBFSl2Z11dXVePjhh7FmzRr4+/tLXY5k0tLSkJaWZn5+0003YcCAAVi1ahVef/11CSvrGSaTCYGBgVi9ejXkcjlSUlJw/vx5vP3223YZWK7X2rVrkZCQgCFDhkhdSo/atWsX3nzzTfzjH//A0KFDkZ+fj2effRavv/46Xn31VanLA+AggcXf3x9yuRxarbZFu1arRXBwsERV9azr6YN33nkHb731Fnbs2IHExERrlmk1Xd1/mUyG2NhYAEBycjKOHTuGZcuW2WVgsbQPTp48idOnT2P8+PHmNpPJBABQKBTIy8tDTEyMdYvuZt3xXaBUKjFo0CDk5+dbo0Sr6sr+h4SEQKlUQi6Xm9sGDBiA4uJiNDY2QqVSWbXm7nY9n4Ha2lps3LgRS5cutWaJVteVPnj11Vfx8MMP47HHHgMAJCQkoLa2Fo8//jgWLFgAmUz6M0ikr6AbqFQqpKSkICMjw9xmMpmQkZHR4l9OjqyrffCXv/wFr7/+OrZs2YLU1NSeKNUquuszYDKZoNfrrVGi1VnaB/3798fhw4eRnZ1tftx111249dZbkZ2djfDw8J4sv1t0x+fAaDTi8OHDCAkJsVaZVtOV/R82bBjy8/PNYRUAjh8/jpCQELsLK8D1fQa++OIL6PV6TJ061dplWlVX+qCurq5VKGkOsaKt3CNZ4pN+u83GjRtFtVotrl+/XszJyREff/xx0dvb23x54sMPPyy+/PLL5uX1er148OBB8eDBg2JISIj4wgsviAcPHhRPnDgh1S5cN0v74K233hJVKpX45Zdftrikr7q6WqpduC6W7v+bb74pbtu2TTx58qSYk5MjvvPOO6JCoRDXrFkj1S5cN0v74GqOcJWQpX2wZMkScevWreLJkyfF/fv3i1OmTBE1Go149OhRqXbhuli6/4WFhaKHh4c4Z84cMS8vT/z222/FwMBA8Y033pBqF65bV/8Ohg8fLk6ePLmny7UKS/tg8eLFooeHh/jZZ5+Jp06dErdt2ybGxMSI999/v1S70IrDBBZRFMW//e1vYu/evUWVSiUOGTJE3Lt3r/m1W265RZw+fbr5eUFBgQig1eOWW27p+cK7kSV9EBER0WYfLF68uOcL7yaW7P+CBQvE2NhYUaPRiD4+PmJaWpq4ceNGCaruXpb0wdUcIbCIomV9MHfuXPOyQUFB4rhx48QDBw5IUHX3sfQzsGfPHnHo0KGiWq0Wo6Ojxf/5n/8Rm5qaerjq7mVpH+Tm5ooAxG3btvVwpdZjSR8YDAbxtddeE2NiYkSNRiOGh4eLTz/9tHjx4sWeL7wdgijayrEeIiIiorY5xDksRERE5NgYWIiIiMjmMbAQERGRzWNgISIiIpvHwEJEREQ2j4GFiIiIbB4DCxEREdk8BhYiIiKyeQwsREREZPMYWIiIiMjmMbAQERGRzfv/uJiRGGqCfWoAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# 生成随机三角形顶点的坐标（范围0到1之间的随机数）\n",
    "triangle = np.random.rand(3, 2)\n",
    "\n",
    "# 分别获取三角形的x和y坐标\n",
    "x = triangle[:, 0]\n",
    "y = triangle[:, 1]\n",
    "\n",
    "# 将三角形顶点的第一个点再添加到最后，形成封闭三角形\n",
    "x = np.append(x, x[0])\n",
    "y = np.append(y, y[0])\n",
    "\n",
    "# 绘制三角形\n",
    "plt.figure()\n",
    "plt.plot(x, y, marker='o')\n",
    "plt.fill(x, y, 'skyblue', alpha=0.5)  # 填充三角形，设置透明度\n",
    "plt.title(\"Random Triangle\")\n",
    "plt.grid(True)\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\leo_l\\AppData\\Local\\Temp\\ipykernel_4276\\309334025.py:16: DeprecationWarning: Arrays of 2-dimensional vectors are deprecated. Use arrays of 3-dimensional vectors instead. (deprecated in NumPy 2.0)\n",
      "  return np.abs(np.cross(p2 - p1, p3 - p1)) < 1e-10\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# 生成一个随机初始三角形\n",
    "def generate_triangle(p1, p2):\n",
    "    # 随机生成第三个点，它不能与已有的两点共线\n",
    "    while True:\n",
    "        p3 = np.random.rand(2)\n",
    "        if not is_collinear(p1, p2, p3):\n",
    "            break\n",
    "    return np.array([p1, p2, p3])\n",
    "\n",
    "# 判断三点是否共线\n",
    "def is_collinear(p1, p2, p3):\n",
    "    # 通过计算向量叉乘，如果结果为零，则三点共线\n",
    "    return np.abs(np.cross(p2 - p1, p3 - p1)) < 1e-10\n",
    "\n",
    "# 生成相邻的多个三角形\n",
    "def generate_adjacent_triangles(num_triangles):\n",
    "    triangles = []\n",
    "    \n",
    "    # 随机生成初始的两个点\n",
    "    p1 = np.random.rand(2)\n",
    "    p2 = np.random.rand(2)\n",
    "    \n",
    "    # 保证初始两个点不重合\n",
    "    while np.allclose(p1, p2):\n",
    "        p2 = np.random.rand(2)\n",
    "\n",
    "    # 生成初始三角形\n",
    "    triangle = generate_triangle(p1, p2)\n",
    "    triangles.append(triangle)\n",
    "    \n",
    "    for _ in range(num_triangles - 1):\n",
    "        # 选择上一三角形的任意一条边\n",
    "        p1, p2 = triangle[np.random.choice([0, 1, 2], 2, replace=False)]\n",
    "        \n",
    "        # 生成与该边相邻的新三角形\n",
    "        triangle = generate_triangle(p1, p2)\n",
    "        triangles.append(triangle)\n",
    "    \n",
    "    return triangles\n",
    "\n",
    "# 绘制三角形\n",
    "def plot_triangles(triangles):\n",
    "    plt.figure()\n",
    "    \n",
    "    for triangle in triangles:\n",
    "        triangle = np.vstack([triangle, triangle[0]])  # 闭合三角形\n",
    "        plt.plot(triangle[:, 0], triangle[:, 1], 'o-', lw=2)\n",
    "        plt.fill(triangle[:, 0], triangle[:, 1], alpha=0.3)\n",
    "    \n",
    "    plt.title(f\"{len(triangles)} Adjacent Triangles\")\n",
    "    plt.grid(True)\n",
    "    plt.show()\n",
    "\n",
    "# 主函数\n",
    "num_triangles = 10  # 生成10个相邻三角形\n",
    "triangles = generate_adjacent_triangles(num_triangles)\n",
    "plot_triangles(triangles)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# 计算两点的法向量\n",
    "def get_normal_vector(p1, p2):\n",
    "    # 计算边 (p2 - p1) 的法向量 (垂直向量)\n",
    "    edge_vector = p2 - p1\n",
    "    normal_vector = np.array([-edge_vector[1], edge_vector[0]])\n",
    "    # 归一化法向量\n",
    "    normal_vector = normal_vector / np.linalg.norm(normal_vector)\n",
    "    return normal_vector\n",
    "\n",
    "# 生成不重叠的三角形\n",
    "def generate_triangle(p1, p2, outward_direction):\n",
    "    # 控制新顶点p3的方向，确保朝外部生成\n",
    "    length = np.random.rand() * 0.5 + 0.3  # 控制顶点距离，避免过大过小\n",
    "    p3 = (p1 + p2) / 2 + outward_direction * length  # 沿法向量方向生成新点\n",
    "    return np.array([p1, p2, p3])\n",
    "\n",
    "# 生成相邻且不重叠的三角形\n",
    "def generate_adjacent_triangles(num_triangles):\n",
    "    triangles = []\n",
    "    \n",
    "    # 初始两个随机点\n",
    "    p1 = np.random.rand(2)\n",
    "    p2 = np.random.rand(2)\n",
    "    \n",
    "    # 保证初始两个点不重合\n",
    "    while np.allclose(p1, p2):\n",
    "        p2 = np.random.rand(2)\n",
    "    \n",
    "    # 法向量用于控制三角形生成的方向\n",
    "    normal_vector = get_normal_vector(p1, p2)\n",
    "    \n",
    "    # 生成第一个三角形\n",
    "    triangle = generate_triangle(p1, p2, normal_vector)\n",
    "    triangles.append(triangle)\n",
    "    \n",
    "    # 逐步生成后续的相邻三角形\n",
    "    for _ in range(num_triangles - 1):\n",
    "        # 选择上一三角形的一条边\n",
    "        p1, p2 = triangle[np.random.choice([0, 1, 2], 2, replace=False)]\n",
    "        \n",
    "        # 计算新的法向量（确保朝外生成）\n",
    "        normal_vector = get_normal_vector(p1, p2)\n",
    "        \n",
    "        # 生成与该边相邻且不重叠的新三角形\n",
    "        triangle = generate_triangle(p1, p2, normal_vector)\n",
    "        triangles.append(triangle)\n",
    "    \n",
    "    return triangles\n",
    "\n",
    "# 绘制三角形\n",
    "def plot_triangles(triangles):\n",
    "    plt.figure()\n",
    "    \n",
    "    for triangle in triangles:\n",
    "        triangle = np.vstack([triangle, triangle[0]])  # 闭合三角形\n",
    "        plt.plot(triangle[:, 0], triangle[:, 1], 'o-', lw=2)\n",
    "        plt.fill(triangle[:, 0], triangle[:, 1], alpha=0.3)\n",
    "    \n",
    "    plt.title(f\"{len(triangles)} Adjacent Non-overlapping Triangles\")\n",
    "    plt.grid(True)\n",
    "    plt.show()\n",
    "\n",
    "# 主函数\n",
    "num_triangles = 10  # 生成10个不重叠的相邻三角形\n",
    "triangles = generate_adjacent_triangles(num_triangles)\n",
    "plot_triangles(triangles)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[4], line 94\u001b[0m\n\u001b[0;32m     92\u001b[0m \u001b[38;5;66;03m# 主函数\u001b[39;00m\n\u001b[0;32m     93\u001b[0m num_triangles \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m10\u001b[39m  \u001b[38;5;66;03m# 生成10个不重叠的相邻三角形\u001b[39;00m\n\u001b[1;32m---> 94\u001b[0m triangles \u001b[38;5;241m=\u001b[39m \u001b[43mgenerate_adjacent_triangles\u001b[49m\u001b[43m(\u001b[49m\u001b[43mnum_triangles\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m     95\u001b[0m plot_triangles(triangles)\n",
      "Cell \u001b[1;32mIn[4], line 68\u001b[0m, in \u001b[0;36mgenerate_adjacent_triangles\u001b[1;34m(num_triangles)\u001b[0m\n\u001b[0;32m     65\u001b[0m     normal_vector \u001b[38;5;241m=\u001b[39m get_normal_vector(p1, p2)\n\u001b[0;32m     67\u001b[0m     \u001b[38;5;66;03m# 生成不重叠的新三角形\u001b[39;00m\n\u001b[1;32m---> 68\u001b[0m     triangle \u001b[38;5;241m=\u001b[39m \u001b[43mgenerate_triangle\u001b[49m\u001b[43m(\u001b[49m\u001b[43mp1\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mp2\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mnormal_vector\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtriangles\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m     69\u001b[0m     triangles\u001b[38;5;241m.\u001b[39mappend(triangle)\n\u001b[0;32m     71\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m triangles\n",
      "Cell \u001b[1;32mIn[4], line 38\u001b[0m, in \u001b[0;36mgenerate_triangle\u001b[1;34m(p1, p2, outward_direction, previous_triangles)\u001b[0m\n\u001b[0;32m     35\u001b[0m     new_triangle \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39marray([p1, p2, p3])\n\u001b[0;32m     37\u001b[0m     \u001b[38;5;66;03m# 检查新三角形是否与已有的三角形重叠\u001b[39;00m\n\u001b[1;32m---> 38\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;43many\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mtriangles_overlap\u001b[49m\u001b[43m(\u001b[49m\u001b[43mnew_triangle\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mprev_triangle\u001b[49m\u001b[43m)\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mprev_triangle\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mprevious_triangles\u001b[49m\u001b[43m)\u001b[49m:\n\u001b[0;32m     39\u001b[0m         \u001b[38;5;28;01mbreak\u001b[39;00m\n\u001b[0;32m     41\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m new_triangle\n",
      "Cell \u001b[1;32mIn[4], line 38\u001b[0m, in \u001b[0;36m<genexpr>\u001b[1;34m(.0)\u001b[0m\n\u001b[0;32m     35\u001b[0m     new_triangle \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39marray([p1, p2, p3])\n\u001b[0;32m     37\u001b[0m     \u001b[38;5;66;03m# 检查新三角形是否与已有的三角形重叠\u001b[39;00m\n\u001b[1;32m---> 38\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28many\u001b[39m(\u001b[43mtriangles_overlap\u001b[49m\u001b[43m(\u001b[49m\u001b[43mnew_triangle\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mprev_triangle\u001b[49m\u001b[43m)\u001b[49m \u001b[38;5;28;01mfor\u001b[39;00m prev_triangle \u001b[38;5;129;01min\u001b[39;00m previous_triangles):\n\u001b[0;32m     39\u001b[0m         \u001b[38;5;28;01mbreak\u001b[39;00m\n\u001b[0;32m     41\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m new_triangle\n",
      "Cell \u001b[1;32mIn[4], line 18\u001b[0m, in \u001b[0;36mtriangles_overlap\u001b[1;34m(triangle1, triangle2)\u001b[0m\n\u001b[0;32m     16\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mmatplotlib\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mpath\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m Path\n\u001b[0;32m     17\u001b[0m path1 \u001b[38;5;241m=\u001b[39m Path(triangle1)\n\u001b[1;32m---> 18\u001b[0m path2 \u001b[38;5;241m=\u001b[39m \u001b[43mPath\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtriangle2\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m     20\u001b[0m \u001b[38;5;66;03m# 检查两个路径是否相交\u001b[39;00m\n\u001b[0;32m     21\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m point \u001b[38;5;129;01min\u001b[39;00m triangle1:\n",
      "File \u001b[1;32mc:\\Users\\leo_l\\.conda\\envs\\test\\lib\\site-packages\\matplotlib\\path.py:99\u001b[0m, in \u001b[0;36mPath.__init__\u001b[1;34m(self, vertices, codes, _interpolation_steps, closed, readonly)\u001b[0m\n\u001b[0;32m     90\u001b[0m \u001b[38;5;66;03m#: A dictionary mapping Path codes to the number of vertices that the\u001b[39;00m\n\u001b[0;32m     91\u001b[0m \u001b[38;5;66;03m#: code expects.\u001b[39;00m\n\u001b[0;32m     92\u001b[0m NUM_VERTICES_FOR_CODE \u001b[38;5;241m=\u001b[39m {STOP: \u001b[38;5;241m1\u001b[39m,\n\u001b[0;32m     93\u001b[0m                          MOVETO: \u001b[38;5;241m1\u001b[39m,\n\u001b[0;32m     94\u001b[0m                          LINETO: \u001b[38;5;241m1\u001b[39m,\n\u001b[0;32m     95\u001b[0m                          CURVE3: \u001b[38;5;241m2\u001b[39m,\n\u001b[0;32m     96\u001b[0m                          CURVE4: \u001b[38;5;241m3\u001b[39m,\n\u001b[0;32m     97\u001b[0m                          CLOSEPOLY: \u001b[38;5;241m1\u001b[39m}\n\u001b[1;32m---> 99\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__init__\u001b[39m(\u001b[38;5;28mself\u001b[39m, vertices, codes\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m, _interpolation_steps\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1\u001b[39m,\n\u001b[0;32m    100\u001b[0m              closed\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m, readonly\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m):\n\u001b[0;32m    101\u001b[0m \u001b[38;5;250m    \u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m    102\u001b[0m \u001b[38;5;124;03m    Create a new path with the given vertices and codes.\u001b[39;00m\n\u001b[0;32m    103\u001b[0m \n\u001b[1;32m   (...)\u001b[0m\n\u001b[0;32m    127\u001b[0m \u001b[38;5;124;03m        and codes as read-only arrays.\u001b[39;00m\n\u001b[0;32m    128\u001b[0m \u001b[38;5;124;03m    \"\"\"\u001b[39;00m\n\u001b[0;32m    129\u001b[0m     vertices \u001b[38;5;241m=\u001b[39m _to_unmasked_float_array(vertices)\n",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.patches import Polygon\n",
    "from matplotlib.collections import PatchCollection\n",
    "\n",
    "# 计算两点的法向量\n",
    "def get_normal_vector(p1, p2):\n",
    "    edge_vector = p2 - p1\n",
    "    normal_vector = np.array([-edge_vector[1], edge_vector[0]])\n",
    "    normal_vector = normal_vector / np.linalg.norm(normal_vector)\n",
    "    return normal_vector\n",
    "\n",
    "# 判断两个三角形是否重叠\n",
    "def triangles_overlap(triangle1, triangle2):\n",
    "    # 使用简单的几何方法进行重叠检查，比如用凸包检查\n",
    "    from matplotlib.path import Path\n",
    "    path1 = Path(triangle1)\n",
    "    path2 = Path(triangle2)\n",
    "    \n",
    "    # 检查两个路径是否相交\n",
    "    for point in triangle1:\n",
    "        if path2.contains_point(point):\n",
    "            return True\n",
    "    for point in triangle2:\n",
    "        if path1.contains_point(point):\n",
    "            return True\n",
    "    return False\n",
    "\n",
    "# 生成不重叠的三角形\n",
    "def generate_triangle(p1, p2, outward_direction, previous_triangles):\n",
    "    # 控制新顶点p3的方向，确保朝外部生成\n",
    "    while True:\n",
    "        length = np.random.rand() * 0.5 + 0.3  # 控制顶点距离\n",
    "        p3 = (p1 + p2) / 2 + outward_direction * length  # 沿法向量方向生成新点\n",
    "        new_triangle = np.array([p1, p2, p3])\n",
    "        \n",
    "        # 检查新三角形是否与已有的三角形重叠\n",
    "        if not any(triangles_overlap(new_triangle, prev_triangle) for prev_triangle in previous_triangles):\n",
    "            break\n",
    "    \n",
    "    return new_triangle\n",
    "\n",
    "# 生成相邻且不重叠的三角形\n",
    "def generate_adjacent_triangles(num_triangles):\n",
    "    triangles = []\n",
    "    \n",
    "    # 初始两个随机点\n",
    "    p1 = np.random.rand(2)\n",
    "    p2 = np.random.rand(2)\n",
    "    \n",
    "    while np.allclose(p1, p2):\n",
    "        p2 = np.random.rand(2)\n",
    "    \n",
    "    normal_vector = get_normal_vector(p1, p2)\n",
    "    \n",
    "    # 生成第一个三角形\n",
    "    triangle = generate_triangle(p1, p2, normal_vector, triangles)\n",
    "    triangles.append(triangle)\n",
    "    \n",
    "    for _ in range(num_triangles - 1):\n",
    "        # 选择上一三角形的一条边\n",
    "        p1, p2 = triangle[np.random.choice([0, 1, 2], 2, replace=False)]\n",
    "        \n",
    "        # 计算新的法向量，确保朝外生成\n",
    "        normal_vector = get_normal_vector(p1, p2)\n",
    "        \n",
    "        # 生成不重叠的新三角形\n",
    "        triangle = generate_triangle(p1, p2, normal_vector, triangles)\n",
    "        triangles.append(triangle)\n",
    "    \n",
    "    return triangles\n",
    "\n",
    "# 绘制三角形\n",
    "def plot_triangles(triangles):\n",
    "    patches = []\n",
    "    \n",
    "    plt.figure()\n",
    "    ax = plt.gca()\n",
    "    \n",
    "    for triangle in triangles:\n",
    "        polygon = Polygon(triangle, closed=True)\n",
    "        patches.append(polygon)\n",
    "    \n",
    "    p = PatchCollection(patches, alpha=0.4, edgecolor='r')\n",
    "    ax.add_collection(p)\n",
    "    \n",
    "    plt.title(f\"{len(triangles)} Adjacent Non-overlapping Triangles\")\n",
    "    plt.grid(True)\n",
    "    plt.gca().set_aspect('equal', adjustable='box')\n",
    "    plt.show()\n",
    "\n",
    "# 主函数\n",
    "num_triangles = 10  # 生成10个不重叠的相邻三角形\n",
    "triangles = generate_adjacent_triangles(num_triangles)\n",
    "plot_triangles(triangles)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 上面的使用一个三角形接着一个三角形生成"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "随机生成的二维图形已导出为 'random_2d_shape.obj'\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "# 生成随机二维顶点\n",
    "def generate_random_2d_shape(num_vertices):\n",
    "    # 随机生成二维平面上的点 (x, y)，每个点的z轴坐标默认为0\n",
    "    points = np.random.rand(num_vertices, 2)\n",
    "    \n",
    "    # 按逆时针顺序对点进行排序，以确保它们形成一个封闭多边形\n",
    "    center = np.mean(points, axis=0)  # 计算中心点\n",
    "    angles = np.arctan2(points[:,1] - center[1], points[:,0] - center[0])\n",
    "    points = points[np.argsort(angles)]\n",
    "    \n",
    "    return points\n",
    "\n",
    "# 将二维顶点写入.obj文件\n",
    "def export_to_obj(vertices, filename=\"random_shape.obj\"):\n",
    "    with open(filename, \"w\") as file:\n",
    "        # 写入顶点\n",
    "        for v in vertices:\n",
    "            file.write(f\"v {v[0]} {v[1]} 0.0\\n\")  # z坐标为0，表示在平面上\n",
    "        \n",
    "        # 写入面（多边形）\n",
    "        file.write(\"f\")\n",
    "        for i in range(1, len(vertices) + 1):\n",
    "            file.write(f\" {i}\")\n",
    "        file.write(\"\\n\")\n",
    "\n",
    "# 主函数，生成随机二维图形并导出为.obj文件\n",
    "num_vertices = 6  # 设置随机图形的顶点数量\n",
    "vertices = generate_random_2d_shape(num_vertices)\n",
    "export_to_obj(vertices, \"random_2d_shape.obj\")\n",
    "\n",
    "print(f\"随机生成的二维图形已导出为 'random_2d_shape.obj'\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 这生成了三维的"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "STL文件已生成: random_2d_shape_extruded.stl\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "from stl import mesh\n",
    "from shapely.geometry import Polygon\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# 生成随机的二维多边形\n",
    "def generate_random_2d_polygon(num_vertices=5):\n",
    "    # 随机生成平面上的点\n",
    "    points = np.random.rand(num_vertices, 2)\n",
    "    \n",
    "    # 按逆时针顺序对点进行排序，形成一个多边形\n",
    "    center = np.mean(points, axis=0)\n",
    "    angles = np.arctan2(points[:,1] - center[1], points[:,0] - center[0])\n",
    "    points = points[np.argsort(angles)]\n",
    "    \n",
    "    # 使用 shapely 生成 Polygon\n",
    "    polygon = Polygon(points)\n",
    "    \n",
    "    return polygon\n",
    "\n",
    "# 将二维多边形挤压成三维几何体\n",
    "def extrude_polygon(polygon, height=1.0):\n",
    "    vertices_2d = np.array(polygon.exterior.coords)\n",
    "    \n",
    "    # 顶面：将2D坐标映射为z=height\n",
    "    top_vertices = np.hstack([vertices_2d, np.full((len(vertices_2d), 1), height)])\n",
    "    \n",
    "    # 底面：将2D坐标映射为z=0\n",
    "    bottom_vertices = np.hstack([vertices_2d, np.zeros((len(vertices_2d), 1))])\n",
    "    \n",
    "    vertices = np.vstack([top_vertices, bottom_vertices])\n",
    "    \n",
    "    faces = []\n",
    "    \n",
    "    # 创建顶面和底面的三角形面片\n",
    "    for i in range(1, len(vertices_2d) - 1):\n",
    "        faces.append([0, i, i + 1])  # 顶面\n",
    "        faces.append([len(vertices_2d), len(vertices_2d) + i, len(vertices_2d) + i + 1])  # 底面\n",
    "    \n",
    "    # 创建侧面的面片\n",
    "    for i in range(len(vertices_2d)):\n",
    "        next_i = (i + 1) % len(vertices_2d)\n",
    "        faces.append([i, next_i, len(vertices_2d) + next_i])\n",
    "        faces.append([i, len(vertices_2d) + next_i, len(vertices_2d) + i])\n",
    "    \n",
    "    return np.array(vertices), np.array(faces)\n",
    "\n",
    "# 导出为STL文件\n",
    "def export_to_stl(vertices, faces, filename=\"2d_shape_extruded.stl\"):\n",
    "    # 创建mesh对象\n",
    "    shape_mesh = mesh.Mesh(np.zeros(faces.shape[0], dtype=mesh.Mesh.dtype))\n",
    "    \n",
    "    for i, face in enumerate(faces):\n",
    "        for j in range(3):\n",
    "            shape_mesh.vectors[i][j] = vertices[face[j], :]\n",
    "    \n",
    "    # 写入stl文件\n",
    "    shape_mesh.save(filename)\n",
    "\n",
    "# 绘制多边形\n",
    "def plot_polygon(polygon):\n",
    "    x, y = polygon.exterior.xy\n",
    "    plt.fill(x, y, alpha=0.5)\n",
    "    plt.show()\n",
    "\n",
    "# 主函数\n",
    "if __name__ == \"__main__\":\n",
    "    # 生成一个随机的二维多边形\n",
    "    polygon = generate_random_2d_polygon(num_vertices=6)\n",
    "    \n",
    "    # 绘制多边形\n",
    "    plot_polygon(polygon)\n",
    "    \n",
    "    # 将二维多边形挤压为三维模型\n",
    "    vertices, faces = extrude_polygon(polygon, height=1.0)\n",
    "    \n",
    "    # 导出为STL文件\n",
    "    export_to_stl(vertices, faces, \"random_2d_shape_extruded.stl\")\n",
    "    \n",
    "    print(f\"STL文件已生成: random_2d_shape_extruded.stl\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'np' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[1], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m points \u001b[38;5;241m=\u001b[39m \u001b[43mnp\u001b[49m\u001b[38;5;241m.\u001b[39mrandom\u001b[38;5;241m.\u001b[39mrand(\u001b[38;5;241m6\u001b[39m, \u001b[38;5;241m2\u001b[39m)\n\u001b[0;32m      3\u001b[0m \u001b[38;5;66;03m# 按逆时针顺序对点进行排序，形成一个多边形\u001b[39;00m\n\u001b[0;32m      4\u001b[0m center \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mmean(points, axis\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0\u001b[39m)\n",
      "\u001b[1;31mNameError\u001b[0m: name 'np' is not defined"
     ]
    }
   ],
   "source": [
    "points = np.random.rand(6, 2)\n",
    "\n",
    "# 按逆时针顺序对点进行排序，形成一个多边形\n",
    "center = np.mean(points, axis=0)\n",
    "angles = np.arctan2(points[:,1] - center[1], points[:,0] - center[0])\n",
    "points = points[np.argsort(angles)]\n",
    "\n",
    "# 使用 shapely 生成 Polygon\n",
    "polygon = Polygon(points)\n",
    "polygon"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 随机生成多边形"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "from shapely.geometry import Polygon\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# 生成包含已知边的随机二维多边形\n",
    "def generate_polygon_with_fixed_edges(fixed_edges, num_random_vertices=4):\n",
    "    # 提取固定边的顶点\n",
    "    fixed_points = np.vstack(fixed_edges)\n",
    "    \n",
    "    # 随机生成其余的点\n",
    "    random_points = np.random.rand(num_random_vertices, 2)\n",
    "    \n",
    "    # 将固定的点和随机点合并在一起\n",
    "    all_points = np.vstack([fixed_points, random_points])\n",
    "    \n",
    "    # 计算所有点的中心点\n",
    "    center = np.mean(all_points, axis=0)\n",
    "    \n",
    "    # 按照与中心点的角度对所有点进行排序（确保按逆时针方向排列）\n",
    "    angles = np.arctan2(all_points[:, 1] - center[1], all_points[:, 0] - center[0])\n",
    "    sorted_points = all_points[np.argsort(angles)]\n",
    "    \n",
    "    # 使用 shapely 生成 Polygon\n",
    "    polygon = Polygon(sorted_points)\n",
    "    \n",
    "    return polygon, sorted_points\n",
    "\n",
    "# 绘制多边形\n",
    "def plot_polygon(polygon, sorted_points):\n",
    "    x, y = polygon.exterior.xy\n",
    "    plt.fill(x, y, alpha=0.4, color='lightblue', label='Random Polygon with Fixed Edges')\n",
    "    plt.plot(x, y, color='black', lw=2)\n",
    "    \n",
    "    # 标记顶点\n",
    "    plt.scatter(sorted_points[:, 0], sorted_points[:, 1], color='red', zorder=5)\n",
    "    \n",
    "    plt.title(\"Random Polygon with Fixed Edges\")\n",
    "    plt.gca().set_aspect('equal', adjustable='box')\n",
    "    plt.grid(True)\n",
    "    plt.show()\n",
    "\n",
    "# 主函数\n",
    "if __name__ == \"__main__\":\n",
    "    # 假设有两个固定的边\n",
    "    fixed_edge_1 = np.array([[0, 0.4], [0, 0.3]])  # 第一条固定边\n",
    "    fixed_edge_2 = np.array([[1, 0.8], [1, 0.9]])  # 第二条固定边\n",
    "    \n",
    "    # 生成一个随机多边形，包含固定的边\n",
    "    polygon, sorted_points = generate_polygon_with_fixed_edges([fixed_edge_1, fixed_edge_2], num_random_vertices=5)\n",
    "    \n",
    "    # 绘制多边形\n",
    "    plot_polygon(polygon, sorted_points)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 固定两个点"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "from shapely.geometry import Polygon\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# 生成包含已知边的随机二维多边形（y坐标要大于0.4或者小于0.3）\n",
    "def generate_polygon_with_fixed_edges(fixed_edges, num_random_vertices=4):\n",
    "    # 提取固定边的顶点\n",
    "    fixed_points = np.vstack(fixed_edges)\n",
    "    \n",
    "    # 随机生成其余的点，满足 y > 0.4 或 y < 0.3\n",
    "    random_points = []\n",
    "    while len(random_points) < num_random_vertices:\n",
    "        point = np.random.rand(2)  # 生成一个随机点\n",
    "        if point[1] > 0.4 or point[1] < 0.3:  # 仅保留 y 坐标符合条件的点\n",
    "            random_points.append(point)\n",
    "    random_points = np.array(random_points)\n",
    "    \n",
    "    # 将固定的点和随机点合并在一起\n",
    "    all_points = np.vstack([fixed_points, random_points])\n",
    "    \n",
    "    # 计算所有点的中心点\n",
    "    center = np.mean(all_points, axis=0)\n",
    "    \n",
    "    # 按照与中心点的角度对所有点进行排序（确保按逆时针方向排列）\n",
    "    angles = np.arctan2(all_points[:, 1] - center[1], all_points[:, 0] - center[0])\n",
    "    sorted_points = all_points[np.argsort(angles)]\n",
    "    \n",
    "    # 使用 shapely 生成 Polygon\n",
    "    polygon = Polygon(sorted_points)\n",
    "    \n",
    "    return polygon, sorted_points\n",
    "\n",
    "# 绘制多边形\n",
    "def plot_polygon(polygon, sorted_points):\n",
    "    x, y = polygon.exterior.xy\n",
    "    plt.fill(x, y, alpha=0.4, color='lightblue', label='Random Polygon with Fixed Edges')\n",
    "    plt.plot(x, y, color='black', lw=2)\n",
    "    \n",
    "    # 标记顶点\n",
    "    plt.scatter(sorted_points[:, 0], sorted_points[:, 1], color='red', zorder=5)\n",
    "    \n",
    "    plt.title(\"Random Polygon with Y > 0.4 or Y < 0.3\")\n",
    "    plt.gca().set_aspect('equal', adjustable='box')\n",
    "    plt.grid(True)\n",
    "    plt.show()\n",
    "\n",
    "# 主函数\n",
    "if __name__ == \"__main__\":\n",
    "    # 假设有两条固定的边\n",
    "    fixed_edge_1 = np.array([[0, 0.4], [0, 0.3]])  # 第一条固定边\n",
    "    fixed_edge_2 = np.array([[1, 0.4], [1, 0.3]])  # 第二条固定边\n",
    "    \n",
    "    # 生成一个随机多边形，包含固定的边，且随机点的y坐标满足要求\n",
    "    polygon, sorted_points = generate_polygon_with_fixed_edges([fixed_edge_1, fixed_edge_2], num_random_vertices=5)\n",
    "    \n",
    "    # 绘制多边形\n",
    "    plot_polygon(polygon, sorted_points)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 三角剖分"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "from shapely.geometry import Polygon\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.tri import Triangulation\n",
    "# 生成包含已知边的随机二维多边形（y坐标要大于0.4或者小于0.3）\n",
    "def generate_polygon_with_fixed_edges(fixed_edges, num_random_vertices=4):\n",
    "    # 提取固定边的顶点\n",
    "    fixed_points = np.vstack(fixed_edges)\n",
    "    \n",
    "    # 随机生成其余的点，满足 y > 0.4 或 y < 0.3\n",
    "    random_points = []\n",
    "    while len(random_points) < num_random_vertices:\n",
    "        point = np.random.rand(2)  # 生成一个随机点\n",
    "        if point[1] > 0.4 or point[1] < 0.3:  # 仅保留 y 坐标符合条件的点\n",
    "            random_points.append(point)\n",
    "    random_points = np.array(random_points)\n",
    "    \n",
    "    # 将固定的点和随机点合并在一起\n",
    "    all_points = np.vstack([fixed_points, random_points])\n",
    "    \n",
    "    # 计算所有点的中心点\n",
    "    center = np.mean(all_points, axis=0)\n",
    "    \n",
    "    # 按照与中心点的角度对所有点进行排序（确保按逆时针方向排列）\n",
    "    angles = np.arctan2(all_points[:, 1] - center[1], all_points[:, 0] - center[0])\n",
    "    sorted_points = all_points[np.argsort(angles)]\n",
    "    \n",
    "    # 使用 shapely 生成 Polygon\n",
    "    polygon = Polygon(sorted_points)\n",
    "    \n",
    "    return polygon, sorted_points\n",
    "\n",
    "# 绘制多边形\n",
    "def plot_polygon(polygon, sorted_points):\n",
    "    x, y = polygon.exterior.xy\n",
    "    plt.fill(x, y, alpha=0.4, color='lightblue', label='Random Polygon with Fixed Edges')\n",
    "    plt.plot(x, y, color='black', lw=2)\n",
    "    \n",
    "    # 标记顶点\n",
    "    plt.scatter(sorted_points[:, 0], sorted_points[:, 1], color='red', zorder=5)\n",
    "    \n",
    "    plt.title(\"Random Polygon with Y > 0.4 or Y < 0.3\")\n",
    "    plt.gca().set_aspect('equal', adjustable='box')\n",
    "    plt.grid(True)\n",
    "    plt.show()\n",
    "\n",
    "# 将多边形划分为多个三角形\n",
    "def triangulate_polygon(polygon):\n",
    "    # 获取多边形的顶点\n",
    "    vertices = np.array(polygon.exterior.coords)\n",
    "    x = vertices[:, 0]\n",
    "    y = vertices[:, 1]\n",
    "    \n",
    "    # 使用 matplotlib 的 Triangulation 进行三角剖分\n",
    "    triangulation = Triangulation(x, y)\n",
    "    \n",
    "    return triangulation\n",
    "# 绘制三角剖分\n",
    "def plot_triangulation(triangulation, polygon):\n",
    "    plt.figure()\n",
    "    \n",
    "    # 绘制多边形的边界\n",
    "    x, y = polygon.exterior.xy\n",
    "    plt.fill(x, y, alpha=0.2, color='lightblue')\n",
    "    plt.plot(x, y, color='black')\n",
    "    \n",
    "    # 绘制三角形\n",
    "    plt.triplot(triangulation, 'go-', lw=1)\n",
    "    \n",
    "    plt.title(\"Polygon Triangulation\")\n",
    "    plt.gca().set_aspect('equal')\n",
    "    plt.grid(True)\n",
    "    plt.show()\n",
    "# 主函数\n",
    "if __name__ == \"__main__\":\n",
    "    # 假设有两条固定的边\n",
    "    fixed_edge_1 = np.array([[0, 0.4], [0, 0.3]])  # 第一条固定边\n",
    "    fixed_edge_2 = np.array([[1, 0.4], [1, 0.3]])  # 第二条固定边\n",
    "    \n",
    "    # 生成一个随机多边形，包含固定的边，且随机点的y坐标满足要求\n",
    "    polygon, sorted_points = generate_polygon_with_fixed_edges([fixed_edge_1, fixed_edge_2], num_random_vertices=5)\n",
    "    \n",
    "    # 绘制多边形\n",
    "    #plot_polygon(polygon, sorted_points)\n",
    "    triangulation = triangulate_polygon(polygon)\n",
    "    \n",
    "    # 绘制多边形及其三角剖分\n",
    "    plot_triangulation(triangulation, polygon)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from shapely.geometry import Polygon\n",
    "from matplotlib.tri import Triangulation\n",
    "\n",
    "# 生成随机的二维多边形\n",
    "def generate_random_2d_polygon(num_vertices=6):\n",
    "    # 随机生成平面上的点\n",
    "    points = np.random.rand(num_vertices, 2)\n",
    "    \n",
    "    # 按逆时针顺序对点进行排序，形成一个多边形\n",
    "    center = np.mean(points, axis=0)\n",
    "    angles = np.arctan2(points[:,1] - center[1], points[:,0] - center[0])\n",
    "    points = points[np.argsort(angles)]\n",
    "    \n",
    "    # 使用 shapely 生成 Polygon\n",
    "    polygon = Polygon(points)\n",
    "    \n",
    "    return polygon\n",
    "\n",
    "# 将多边形划分为多个三角形\n",
    "def triangulate_polygon(polygon):\n",
    "    # 获取多边形的顶点\n",
    "    vertices = np.array(polygon.exterior.coords)\n",
    "    x = vertices[:, 0]\n",
    "    y = vertices[:, 1]\n",
    "    \n",
    "    # 使用 matplotlib 的 Triangulation 进行三角剖分\n",
    "    triangulation = Triangulation(x, y)\n",
    "    \n",
    "    return triangulation\n",
    "\n",
    "# 绘制三角剖分\n",
    "def plot_triangulation(triangulation, polygon):\n",
    "    plt.figure()\n",
    "    \n",
    "    # 绘制多边形的边界\n",
    "    x, y = polygon.exterior.xy\n",
    "    plt.fill(x, y, alpha=0.2, color='lightblue')\n",
    "    plt.plot(x, y, color='black')\n",
    "    \n",
    "    # 绘制三角形\n",
    "    plt.triplot(triangulation, 'go-', lw=1)\n",
    "    \n",
    "    plt.title(\"Polygon Triangulation\")\n",
    "    plt.gca().set_aspect('equal')\n",
    "    plt.grid(True)\n",
    "    plt.show()\n",
    "\n",
    "# 主函数\n",
    "if __name__ == \"__main__\":\n",
    "    # 生成一个随机的二维多边形\n",
    "    polygon = generate_random_2d_polygon(num_vertices=7)\n",
    "    \n",
    "    # 对多边形进行三角剖分\n",
    "    triangulation = triangulate_polygon(polygon)\n",
    "    \n",
    "    # 绘制多边形及其三角剖分\n",
    "    plot_triangulation(triangulation, polygon)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "ename": "",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31mThe Kernel crashed while executing code in the current cell or a previous cell. \n",
      "\u001b[1;31mPlease review the code in the cell(s) to identify a possible cause of the failure. \n",
      "\u001b[1;31mClick <a href='https://aka.ms/vscodeJupyterKernelCrash'>here</a> for more info. \n",
      "\u001b[1;31mView Jupyter <a href='command:jupyter.viewOutput'>log</a> for further details."
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from shapely.geometry import Polygon, Point\n",
    "import triangle\n",
    "\n",
    "# 生成随机的二维多边形\n",
    "def generate_random_2d_polygon(num_vertices=6):\n",
    "    # 随机生成平面上的点\n",
    "    points = np.random.rand(num_vertices, 2)\n",
    "    \n",
    "    # 按逆时针顺序对点进行排序，形成一个多边形\n",
    "    center = np.mean(points, axis=0)\n",
    "    angles = np.arctan2(points[:,1] - center[1], points[:,0] - center[0])\n",
    "    points = points[np.argsort(angles)]\n",
    "    \n",
    "    # 使用 shapely 生成 Polygon\n",
    "    polygon = Polygon(points)\n",
    "    \n",
    "    return polygon\n",
    "\n",
    "# 为多边形添加边界约束并进行三角剖分\n",
    "def constrained_triangulation(polygon):\n",
    "    vertices = np.array(polygon.exterior.coords)\n",
    "    \n",
    "    # 构建约束：我们希望多边形的边保持不变\n",
    "    constraints = np.array([[i, (i+1) % len(vertices)] for i in range(len(vertices)-1)])\n",
    "\n",
    "    # 使用 triangle 进行带约束的 Delaunay 三角剖分\n",
    "    A = dict(vertices=vertices, segments=constraints)\n",
    "    triangulation = triangle.triangulate(A, 'p')  # 'p' 选项表示保留边界约束\n",
    "\n",
    "    return triangulation\n",
    "\n",
    "# 绘制三角剖分结果\n",
    "def plot_triangulation(triangulation, polygon):\n",
    "    plt.figure()\n",
    "    \n",
    "    # 绘制多边形的原始边界\n",
    "    x, y = polygon.exterior.xy\n",
    "    plt.fill(x, y, alpha=0.3, color='lightblue', label='Original Polygon')\n",
    "    plt.plot(x, y, color='black')\n",
    "    \n",
    "    # 绘制三角剖分\n",
    "    vertices = triangulation['vertices']\n",
    "    triangles = triangulation['triangles']\n",
    "    \n",
    "    for triangle in triangles:\n",
    "        triangle_coords = vertices[triangle]\n",
    "        plt.plot(triangle_coords[[0, 1, 2, 0], 0], triangle_coords[[0, 1, 2, 0], 1], 'r-', lw=1)\n",
    "    \n",
    "    plt.title(\"Constrained Triangulation\")\n",
    "    plt.gca().set_aspect('equal', adjustable='box')\n",
    "    plt.grid(True)\n",
    "    plt.legend()\n",
    "    plt.show()\n",
    "\n",
    "# 主函数\n",
    "if __name__ == \"__main__\":\n",
    "    # 生成一个随机的二维多边形\n",
    "    polygon = generate_random_2d_polygon(num_vertices=7)\n",
    "    \n",
    "    # 对多边形进行带约束的三角剖分\n",
    "    triangulation = constrained_triangulation(polygon)\n",
    "    \n",
    "    # 绘制带约束的三角剖分\n",
    "    plot_triangulation(triangulation, polygon)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 新库不带约束的三角剖分"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import triangle\n",
    "\n",
    "# 生成一个随机的二维多边形\n",
    "def generate_random_2d_polygon(num_vertices=6):\n",
    "    points = np.random.rand(num_vertices, 2)\n",
    "    center = np.mean(points, axis=0)\n",
    "    angles = np.arctan2(points[:, 1] - center[1], points[:, 0] - center[0])\n",
    "    points = points[np.argsort(angles)]\n",
    "    return points\n",
    "\n",
    "# 对多边形进行三角剖分\n",
    "def constrained_triangulation(polygon_points):\n",
    "    vertices = np.array(polygon_points)\n",
    "    # 定义约束边，保持多边形的边界不被破坏\n",
    "    segments = np.array([[i, (i + 1) % len(vertices)] for i in range(len(vertices))])\n",
    "    \n",
    "    # 使用 triangle 库进行带约束的三角剖分\n",
    "    A = dict(vertices=vertices, segments=segments)\n",
    "    triangulation = triangle.triangulate(A, 'p')\n",
    "    \n",
    "    return triangulation\n",
    "\n",
    "# 绘制三角剖分\n",
    "def plot_triangulation(triangulation):\n",
    "    plt.figure()\n",
    "    vertices = triangulation['vertices']\n",
    "    triangles = triangulation['triangles']\n",
    "    \n",
    "    for triangle in triangles:\n",
    "        t = vertices[triangle]\n",
    "        plt.fill(t[:, 0], t[:, 1], 'lightblue', edgecolor='k')\n",
    "    \n",
    "    plt.gca().set_aspect('equal')\n",
    "    plt.title(\"Constrained Triangulation with triangle Library\")\n",
    "    plt.grid(True)\n",
    "    plt.show()\n",
    "\n",
    "# 主程序\n",
    "if __name__ == \"__main__\":\n",
    "    num_vertices = 7  # 多边形的顶点数量\n",
    "    polygon_points = generate_random_2d_polygon(num_vertices)\n",
    "    \n",
    "    # 进行带约束的三角剖分\n",
    "    triangulation = constrained_triangulation(polygon_points)\n",
    "    \n",
    "    # 绘制剖分结果\n",
    "    plot_triangulation(triangulation)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 最终的剖分"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAbcAAAGzCAYAAACsBln9AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAACoI0lEQVR4nOzddVwUWx/H8c/SJSoKdmEHomKCgGAgdneA3YHdit2Nit2F3a3XuraiWAhiiy1Kxzx/eOW5XEGJ3R3ivF+v+3oeh5lzvju77I+dPXOOQpIkCUEQBEFIRzTkDiAIgiAIyiaKmyAIgpDuiOImCIIgpDuiuAmCIAjpjihugiAIQrojipsgCIKQ7ojiJgiCIKQ7orgJgiAI6Y4oboIgCEK6I4pbGqRQKJg4caIsfdeoUYMaNWqorP2zZ8+iUCg4e/asyvpQFVU8L6o+38rm4uJCwYIFE72vkZGRagP9x7p161AoFAQEBKi134Qk5XwpS3y/YzVq1KBMmTJqzaFqaba4+fn50bNnT8zNzdHT08PY2BgbGxsWLlxIaGiorNkOHz4sW/GR28SJE1EoFH/8Ly29Yava/fv3mThxYqp5w1WmkJAQJk6cqJI/Vjw8PFi3bp3S203Lfv7+ffjwQe4ostOSO0ByHDp0iJYtW6Krq0unTp0oU6YMERERXLhwgWHDhuHj44Onp6ds+Q4fPszSpUtVVuBCQ0PR0kqdT12zZs0oUqRI7L+/f/9O7969adq0Kc2aNYvdniNHjniPt7OzIzQ0FB0dHZVnTS3u37/PpEmTqFGjxi9/xR8/flyeUMm0cuVKYmJiYv8dEhLCpEmTAJT+B42HhwfZs2fHxcUl0cd07NiRNm3aoKurq9QsaUlG+R1Lne+Qv/H06VPatGlDgQIFOH36NLly5Yr9Wd++fXny5AmHDh2SMWHSREVFERMTk6QXmp6engoTpUzZsmUpW7Zs7L8/fPhA7969KVu2LB06dEjwuLCwMHR0dNDQ0EjVj0/d0tobkLa2ttwR4hUcHIyhoSGamppoamrKHUdWyv4d+/fvrpxt/Feauyw5a9Ysvn//zurVq+MUtp+KFCnCwIEDY/8dFRXF5MmTKVy4MLq6uhQsWJDRo0cTHh4e57iCBQvSoEEDLly4QOXKldHT08Pc3JwNGzbE2S8yMpJJkyZRtGhR9PT0yJYtG9WrV+fEiRPAj2voS5cuBYhzGQ4gICAAhULBnDlzWLBgQWym+/fvExERwfjx47GysiJz5swYGhpia2vLmTNnfnmM//1u5+eliCdPnuDi4kKWLFnInDkzrq6uhISE/HL8pk2bsLKyQl9fHxMTE9q0acOLFy9+2c/T05PChQujr69P5cqVOX/+fEJPS5L8vOa/bds2xo4dS548eTAwMCAoKCje7wPOnz9Py5YtyZ8/P7q6uuTLl4/Bgwf/cvn553c4r169okmTJhgZGWFqasrQoUOJjo6Os+/Hjx/p2LEjxsbGZMmShc6dO3Pnzh0UCkWcS10JfeeVmO9Knj17Rp8+fShevDj6+vpky5aNli1bxrn8uG7dOlq2bAmAg4ND7Ovl5+OPr/93797RtWtXcuTIgZ6eHpaWlqxfvz7OPv9+rf18HnV1dalUqRLXrl37be4vX76gqanJokWLYrd9+PABDQ0NsmXLxr8XEunduzc5c+aM97wEBARgamoKwKRJk2If23+vaCTm+fqvggUL4uPjw7lz53651P3ze7Vz587Rp08fzMzMyJs3b5yf/fs52LdvH/Xr1yd37tzo6upSuHBhJk+e/EuGn99L3b9/HwcHBwwMDMiTJw+zZs36Jd+zZ89o1KgRhoaGmJmZMXjwYI4dO5ao75NjYmJYsGABpUuXRk9Pjxw5ctCzZ08+f/782+MS63ffa9+4cQNra2v09fUpVKgQy5cvj/fY+H53P336xNChQ7GwsMDIyAhjY2OcnZ25c+dOotq4ffs2CoWC+fPn/5Lr0qVLKBQKtm7dmujHmeY+uR04cABzc3Osra0TtX+3bt1Yv349LVq0YMiQIVy5coXp06fz4MED9uzZE2ffJ0+e0KJFC7p27Urnzp1Zs2YNLi4uWFlZUbp0aeBHIZk+fTrdunWjcuXKBAUFcf36dW7evEnt2rXp2bMnr1+/5sSJE2zcuDHeTGvXriUsLIwePXqgq6uLiYkJQUFBrFq1irZt29K9e3e+ffvG6tWrcXJy4urVq5QrV+6Pj7VVq1YUKlSI6dOnc/PmTVatWoWZmRkzZ86M3Wfq1KmMGzeOVq1a0a1bN96/f8/ixYuxs7Pj1q1bZMmSBYDVq1fTs2dPrK2tGTRoEP7+/jRq1AgTExPy5cuXqHP/J5MnT0ZHR4ehQ4cSHh6e4KeUnTt3EhISQu/evcmWLRtXr15l8eLFvHz5kp07d8bZNzo6GicnJ6pUqcKcOXM4efIkc+fOpXDhwvTu3Rv48ebRsGFDrl69Su/evSlRogT79u2jc+fOSnlcP127do1Lly7Rpk0b8ubNS0BAAMuWLaNGjRrcv38fAwMD7OzsGDBgAIsWLWL06NGULFkSIPZ//ys0NJQaNWrw5MkT+vXrR6FChdi5cycuLi58+fIlzh92AFu2bOHbt2/07NkThULBrFmzaNasGf7+/gl+ysqSJQtlypThr7/+YsCAAQBcuHABhULBp0+fuH//fuzvw/nz57G1tY23HVNTU5YtW/bLZel/f7JPzPMVnwULFtC/f3+MjIwYM2YM8Oul7j59+mBqasr48eMJDg5OsK1169ZhZGSEm5sbRkZGnD59mvHjxxMUFMTs2bPj7Pv582fq1q1Ls2bNaNWqFV5eXowYMQILCwucnZ2BH58SHR0defPmDQMHDiRnzpxs2bIl3j9U49OzZ0/WrVuHq6srAwYM4OnTpyxZsoRbt25x8eJFlX06/vz5M/Xq1aNVq1a0bduWHTt20Lt3b3R0dOjSpUucfeP73b1//z579+6lZcuWFCpUiMDAQFasWIG9vT33798nd+7cv22jRIkS2NjYsHnzZgYPHhxn382bN5MpUyYaN26c+AckpSFfv36VAKlx48aJ2v/27dsSIHXr1i3O9qFDh0qAdPr06dhtBQoUkADpr7/+it327t07SVdXVxoyZEjsNktLS6l+/fq/7bdv375SfKf26dOnEiAZGxtL7969i/OzqKgoKTw8PM62z58/Szly5JC6dOkSZzsgTZgwIfbfEyZMkIBf9mvatKmULVu22H8HBARImpqa0tSpU+Psd/fuXUlLSyt2e0REhGRmZiaVK1cuTiZPT08JkOzt7X/7+P/t/fv3v+Q9c+aMBEjm5uZSSEhInP1//uzMmTOx2/67jyRJ0vTp0yWFQiE9e/Ysdlvnzp0lQHJ3d4+zb/ny5SUrK6vYf+/atUsCpAULFsRui46OlhwdHSVAWrt2bex2e3v7eB9v586dpQIFCsTZ9t/HGV/uy5cvS4C0YcOG2G07d+785TEn1P+CBQskQNq0aVPstoiICKlatWqSkZGRFBQUJEnS/19r2bJlkz59+hS77759+yRAOnDgwC99/Vvfvn2lHDlyxP7bzc1NsrOzk8zMzKRly5ZJkiRJHz9+lBQKhbRw4cIEz0t8z/+/903M85WQ0qVLx/vcrF27VgKk6tWrS1FRUfH+7OnTp7Hb4nueevbsKRkYGEhhYWGx2+zt7X957sLDw6WcOXNKzZs3j902d+5cCZD27t0buy00NFQqUaLEL8/zf8/X+fPnJUDavHlznDxHjx6Nd/t//XwveP/+fYL7xPc79vOxzZ07N85jK1eunGRmZiZFRETEOTa+392wsDApOjo6zranT59Kurq6cZ7j37WxYsUKCZAePHgQuy0iIkLKnj271Llz598+9v9KU5clg4KCAMiUKVOi9j98+DAAbm5ucbYPGTIE4Jfv5kqVKhXnr1BTU1OKFy+Ov79/7LYsWbLg4+ODr69v0h/AP5o3bx57ueYnTU3N2E8uMTExfPr0iaioKCpWrMjNmzcT1W6vXr3i/NvW1paPHz/Gnrfdu3cTExNDq1at+PDhQ+x/OXPmpGjRorF/WV6/fp13797Rq1evOJ+mXFxcyJw5c7If93917twZfX39P+73732Cg4P58OED1tbWSJLErVu3ftk/vvPw7+fw6NGjaGtr071799htGhoa9O3bNzkPI1G5IyMj+fjxI0WKFCFLliyJfk7/6/Dhw+TMmZO2bdvGbtPW1mbAgAF8//6dc+fOxdm/devWZM2aNfbfP1/f/z4f8bG1tSUwMJBHjx4BPz6h2dnZYWtrG3t5+sKFC0iSlOAnt8T60/OVXN27d0/U92v/fp6+ffvGhw8fsLW1JSQkhIcPH8bZ18jIKM53xzo6OlSuXPmX11eePHlo1KhR7DY9Pb04r7eE7Ny5k8yZM1O7du04v6NWVlYYGRkl+tNfcmhpadGzZ8/Yf+vo6NCzZ0/evXvHjRs34uwb3++urq5u7Hdm0dHRfPz4ESMjI4oXLx7v6z2+Nlq1aoWenh6bN2+O3Xbs2DE+fPjw2+/s45OmipuxsTHw4wWYGM+ePUNDQyPO6D2AnDlzkiVLFp49exZne/78+X9pI2vWrHGudbu7u/PlyxeKFSuGhYUFw4YNw9vbO0mPo1ChQvFuX79+PWXLlo39Ls/U1JRDhw7x9evXRLX73/w/39R+5vf19UWSJIoWLYqpqWmc/x48eMC7d+8AYs9L0aJF47Snra2Nubl54h/oHyR0Hv7r+fPnuLi4YGJiEvu9jL29PcAv50ZPT++XPxz++xw+e/aMXLlyYWBgEGe//75OUio0NJTx48eTL18+dHV1yZ49O6ampnz58iXRz+l/PXv2jKJFi/7yxfvPy5h/ek3/9zWRkJ8F6/z58wQHB3Pr1i1sbW2xs7OLLW7nz5/H2NgYS0vLZD0WSNzzlVyJfX35+PjQtGlTMmfOjLGxMaamprFvpP99nvLmzRv7HXpCeZ89e0bhwoV/2S8xry9fX1++fv2KmZnZL7+j379/j/0dVYXcuXNjaGgYZ1uxYsUAfrlNJb5zGxMTw/z58ylatGic17u3t3e8r/f42siSJQsNGzZky5Ytsds2b95Mnjx5cHR0TNLjSVPfuRkbG5M7d27u3buXpOP++yJLSEJ/5Un/+gLdzs4OPz8/9u3bx/Hjx1m1ahXz589n+fLldOvWLVH9xPdpZdOmTbi4uNCkSROGDRuGmZkZmpqaTJ8+HT8/P6Xkj4mJQaFQcOTIkXj3VfcNtYn51BYdHU3t2rX59OkTI0aMoESJEhgaGvLq1StcXFziDDuHhM9BcikUijjP/79z/Un//v1Zu3YtgwYNolq1amTOnBmFQkGbNm1+ya0qiXlNxyd37twUKlSIv/76i4IFCyJJEtWqVcPU1JSBAwfy7Nkzzp8/j7W1dYpGuKly5GJiXl9fvnzB3t4eY2Nj3N3dKVy4MHp6ety8eZMRI0Yk+vX1p/OZWDExMZiZmcX55PJv//1DQC7xndtp06Yxbtw4unTpwuTJkzExMUFDQ4NBgwbF+3pP6Pnp1KkTO3fu5NKlS1hYWLB//3769OmT5NdZmipuAA0aNMDT05PLly9TrVq13+5boEABYmJi8PX1jfMFfWBgIF++fKFAgQLJymBiYoKrqyuurq58//4dOzs7Jk6cGFvcEltM/83Lywtzc3N2794d5/gJEyYkK2N8ChcujCRJFCpUKPYvsvj8PC++vr5x/lqKjIzk6dOnKfpLPanu3r3L48ePWb9+PZ06dYrd/nN0anIUKFCAM2fOEBISEufT25MnT37ZN2vWrPFeIvvvJ6T4eHl50blzZ+bOnRu7LSwsjC9fvsTZLymvlwIFCuDt7U1MTEycX/afl8+S+5qOj62tLX/99ReFChWiXLlyZMqUCUtLSzJnzszRo0e5efNm7D1sCUnO70JiKaPts2fP8vHjR3bv3o2dnV3s9qdPnya7zQIFCnD//n0kSYqTMb7X138VLlyYkydPYmNjk6jirEyvX7+OvWXip8ePHwMkahYVLy8vHBwcWL16dZztX758IXv27InOUbduXUxNTdm8eTNVqlQhJCSEjh07Jvr4n9LUZUmA4cOHY2hoSLdu3QgMDPzl535+fixcuBCAevXqAT9GVv3bvHnzAKhfv36S+//48WOcfxsZGVGkSJE4txb8fHH8903sd37+RfjvvwCvXLnC5cuXk5wxIc2aNUNTU5NJkyb98pemJEmxj61ixYqYmpqyfPlyIiIiYvdZt25dkh6TMsR3XiRJin2Ok8PJyYnIyEhWrlwZuy0mJib2Fo5/K1y4MA8fPuT9+/ex2+7cucPFixcTlf2/53nx4sW/fOpLyuulXr16vH37lu3bt8dui4qKYvHixRgZGcVerlUGW1tbAgIC2L59e+xlSg0NDaytrZk3bx6RkZF//L7t5x8PqnjdGBoaprjd+F5fEREReHh4JLtNJycnXr16xf79+2O3hYWFxXm9JaRVq1ZER0czefLkX34WFRWl0t+/qKgoVqxYEfvviIgIVqxYgampKVZWVn88Pr7X+86dO3n16lWScmhpacWO1ly3bh0WFhZxRtgmup0kHyGzwoULs2XLFlq3bk3JkiXjzFBy6dKl2GHRAJaWlnTu3BlPT8/Yyw9Xr15l/fr1NGnSBAcHhyT3X6pUKWrUqIGVlRUmJiZcv34dLy8v+vXrF7vPzxfCgAEDcHJyQlNTkzZt2vy23QYNGrB7926aNm1K/fr1efr0KcuXL6dUqVJ8//49yTnjU7hwYaZMmcKoUaMICAigSZMmZMqUiadPn7Jnzx569OjB0KFD0dbWZsqUKfTs2RNHR0dat27N06dPWbt2rVK/c0uMEiVKULhwYYYOHcqrV68wNjZm165dKfpOpkmTJlSuXJkhQ4bw5MkTSpQowf79+/n06RMQ9xNBly5dmDdvHk5OTnTt2pV3796xfPlySpcuHTtQJyENGjRg48aNZM6cmVKlSnH58mVOnjxJtmzZ4uxXrlw5NDU1mTlzJl+/fkVXVxdHR0fMzMx+abNHjx6sWLECFxcXbty4QcGCBfHy8uLixYssWLAg0YOtEuNn4Xr06BHTpk2L3W5nZ8eRI0di75v7HX19fUqVKsX27dspVqwYJiYmlClTRinzGFpZWbFs2TKmTJlCkSJFMDMzS/L3MtbW1mTNmpXOnTszYMAAFAoFGzduTNFlxp49e7JkyRLatm3LwIEDyZUrF5s3b469cfp3nzjt7e3p2bMn06dP5/bt29SpUwdtbW18fX3ZuXMnCxcupEWLFn/MMG/evF++U9bQ0GD06NEJHpM7d25mzpxJQEAAxYoVY/v27dy+fRtPT89E3X7QoEED3N3dcXV1xdramrt377J58+ZkvWd06tSJRYsWcebMmTi3MiVJksZWpiKPHz+WunfvLhUsWFDS0dGRMmXKJNnY2EiLFy+OM3w3MjJSmjRpklSoUCFJW1tbypcvnzRq1Kg4+0jSj1sB4hvi/9+h2FOmTJEqV64sZcmSRdLX15dKlCghTZ06NXaorCT9GNbfv39/ydTUVFIoFLG3Bfwcnj179uxf+omJiZGmTZsmFShQQNLV1ZXKly8vHTx4MFFDzhMa/hvfsGdJ+jEUvnr16pKhoaFkaGgolShRQurbt6/06NGjOPt5eHhIhQoVknR1daWKFStKf/31V4JD4xPyu1sBdu7c+cv+8Q1Tvn//vlSrVi3JyMhIyp49u9S9e3fpzp07vwzb79y5s2RoaPhLmz/Pz39ztWvXTsqUKZOUOXNmycXFRbp48aIESNu2bYuz76ZNmyRzc3NJR0dHKleunHTs2LFEPS+fP3+WXF1dpezZs0tGRkaSk5OT9PDhQ6lAgQK/DGteuXKlZG5uLmlqasZ5/PGd78DAwNh2dXR0JAsLizjnQZJ+/1r7b87fMTMzkwApMDAwdtuFCxckQLK1tf1l//jOy6VLlyQrKytJR0cnTt9Jeb7i8/btW6l+/fpSpkyZ4tyi8vN1f+3atV+Oie934uLFi1LVqlUlfX19KXfu3NLw4cOlY8eOxTtcvnTp0ol6zP7+/lL9+vUlfX19ydTUVBoyZEjsLSh///33b4+VpB+33VhZWUn6+vpSpkyZJAsLC2n48OHS69evf3tOfp67+P7T1NSUJCnhWwFKly4tXb9+XapWrZqkp6cnFShQQFqyZEmc9n/3uxsWFiYNGTJEypUrl6Svry/Z2NhIly9f/uU1/Ls2/q106dKShoaG9PLly9/ulxCFJCnpm1BBSOP27t1L06ZNuXDhAjY2NnLHEdKZBQsWMHjwYF6+fEmePHnkjpPqlS9fHhMTE06dOpWs49Pcd26CoAz/nborOjqaxYsXY2xsTIUKFWRKJaQX/319hYWFsWLFCooWLSoKWyJcv36d27dvxxlEllRp7js3QVCG/v37ExoaSrVq1QgPD2f37t1cunSJadOmqX2UmpD+NGvWjPz581OuXDm+fv3Kpk2bePjwYYJD/IUf7t27x40bN5g7dy65cuWidevWyW5LFDchQ3J0dGTu3LkcPHiQsLAwihQpwuLFi+MMDBKE5HJycmLVqlVs3ryZ6OhoSpUqxbZt21L0Zp0ReHl54e7uTvHixdm6dWuKVi8Q37kJgiAI6Y74zk0QBEFId0RxEwRBENKdNPGdW0xMDK9fvyZTpkwqnc5HEARBSN0kSeLbt2/kzp37t/NNponi9vr1a6UtkCkIgiCkfS9evIhdYT0+aaK4/ZxS6MWLF7HL3iRVZGQkx48fj53ORvg/cW4SJs5N/MR5SZg4N/FT1nkJCgoiX758f5xqLk0Ut5+XIo2NjVNU3AwMDDA2NhYvuP8Q5yZh4tzET5yXhIlzEz9ln5c/fUWV5AElf/31Fw0bNiR37twoFAr27t37x2POnj1LhQoV0NXVpUiRIqxbty6p3QqCIAhCoiW5uAUHB2NpaRnv8iDxefr0KfXr18fBwYHbt28zaNAgunXrxrFjx5IcVhAEQRASI8mXJZ2dnXF2dk70/suXL6dQoUKxCzaWLFmSCxcuMH/+fJycnJLavSAIgiD8kcq/c7t8+TK1atWKs83JyYlBgwYleEx4eHicxT9/rpsVGRlJZGRksnL8PC65x6dn4twkTJyb+InzkjBxbuKnrPOS2ONVXtzevn1Ljhw54mzLkSMHQUFBhIaGxjtJ7fTp0+Ndvv748eO/LMCXVCdOnEjR8emZODcJE+cmfuK8JEycm/il9LyEhIQkar9UOVpy1KhRuLm5xf7759DPOnXqpGi05IkTJ6hdu7YYwfQf4twkTJyb+InzkjBxbuKnrPPy80ren6i8uOXMmZPAwMA42wIDAzE2Nk5waRFdXV10dXV/2a6trZ3iF4sy2kivxLlJmDg38RPnJWHi3MQvpeclsceqfG7JatWq/bKS6okTJ6hWrZqquxYEQRAyqCQXt+/fv3P79m1u374N/Bjqf/v2bZ4/fw78uKT479VTe/Xqhb+/P8OHD+fhw4d4eHiwY8cOBg8erJxHIAiCIAj/keTidv36dcqXL0/58uUBcHNzo3z58owfPx6AN2/exBY6gEKFCnHo0CFOnDiBpaUlc+fOZdWqVeI2AEEQBEFlkvydW40aNfjd+qbxzT5So0YNbt26ldSuBEEQBCFZxHpugiAIQrojipsgCMK//O7KlJB2iOImCILwj8+fP1O1ajVKlS5DWFiY3HGEFBDFTRAEAXj37h01ajjw4NEjHtz3Ydu2bXJHElJAFDdBEDK8ly9fYmtnx8u3b3HftIfytg4sWrRYXKJMw0RxEwQhQ/P396e6rS1fvgXjvnE3+YsWx7lDF27dusnly5fljickkyhugiBkWA8ePKC6rS2RaDB58x5yFSgEQHlbB3IXKMTixYtlTigklyhugiBkSLdv38bWzg4dI2PcN+4me648sT/T0NDAqZ0LXl5evH79WsaUQnKJ4iYIQobz999/U8PBgaw58zBpvRdZTc1+2cehWWu0dXRZsWKFDAmFlBLFTRCEDOXMmTPUrFWLPEWKM2HdDjJlNYl3P8NMxtg1bsHyFSuIiIhQc0ohpURxEwQhwzh8+DD16tWjWPmKjF25GQOjTL/d37m9K+8CA/Hy8lJTQkFZRHETBCFD8PLyokmTJlhWr8FIj3Xo6hv88Zh8RYpRtpotixaJgSVpjShugiCke+vXr6d169ZUdWqA2/wVaOv8uhhyQpw7uHLlyt9cv35dhQkFZRPFTRCEdM3DwwMXFxccm7el/8xFaCVxFWirGrXJkTefuC0gjRHFTRCEdGvWrFn07duXBp170Mt9FpqamkluQ1NTkzptO7Nt2zbevXungpSCKojiJghCuiNJEuPHj2fEiBG07DMYl5ETUCgUyW6vZvO2KDQ0WblypRJTCqokipsgCOmKJEm4ubkxefJkOg4bS5sBw1JU2AAyZcmKbcOmeCxbRmRkpJKSCqokipsgCOlGdHQ03bt3Z8GCBXQfP40mXfsorW3nDl14/eoVe/fuVVqbguqI4iYIQroQGRlJx44dWbt2Lf2mL6BuOxeltl+weClKV6oqbgtII0RxEwQhzQsLC6NFy5bs9PLCbd5yHJq2Ukk/zu27cOHCee7cuaOS9gXlEcVNEIQ0LTg4mIYNG3H06DGGL1lDtboNVNZXpZpOZM+Zi0WLFqmsD0E5RHETBCHN+vr1K05163Lx0iVGr9iIlX1Nlfanpa1N7Tad2LJlCx8/flRpX0LKiOImCEKa9PHjRxxr1uSO913Gr9mGRVUbtfRbu2V7omNiWL16tVr6E5JHFDdBENKct2/fYm9fA/+AZ0xcv5Ni5azU1nfmbNmxcW7MUg8PoqOj1davkDSiuAmCkKY8f/6c6ra2BH78yKSNuyhUsozaMzh36MLzZ884cOCA2vsWEkcUN0EQ0gxfX1+q29oSHB6B+6Y95DUvKkuOIhaWFC9nxSIx32SqJYqbIAhpwr1797C1s0PS1sV90x5y5M0vax7n9q6cOX0aHx8fWXMI8RPFTRCEVO/GjRvY2dtjmDU77ht2kS1HLrkjUdWpASamZixZskTuKEI8RHETBCFVu3DhAg6OjpjlL8SEdTvInC273JEA0NbRoVarDqzfsIEvX77IHUf4D1HcBEFItU6ePEkdJycKlCjDuFVbMcqcRe5IcdRp3ZGIiAjWrl0rdxThP0RxEwQhVdq/fz/169enVKVqjPbciL6RkdyRfpHVLAfWTg1YsnQpMTExcscR/kUUN0EQUp1t27bRrFkzrBzqMGzxanT19OWOlCDnDl3w9/Pj6NGjckcR/kUUN0EQUpXVq1fTrl077Bo2Z/BcD7R1dOSO9FvFyllRpExZsVpAKiOKmyAIqcbChQvp1q0bTm070WfaPDS1tOSO9EcKhYK67btw7NhRHj9+LHcc4R+iuAmCkCpMmzaNQYMG0aRbH7qNm4aGRtp5e7Kp14jMJtlYunSp3FGEf6SdV48gCOmSJEmMGjWKMWPG0HbgcDoMGYNCoZA7VpLo6OpRs2V71qxdy/fv3+WOIyCKmyAIMoqJiaF///7MmDEDl5ETadF7UJorbD/VbduJ0JAQtm7dKncUAVHcBEGQSVRUFF27dsXDw4Ne7rNp6NJD7kgpki1nbirXcmbFCk+5owiI4iYIggwiIiJo264dGzduZOCsxdRu1V7uSErh3KELvr5iUElqkPqHIgmCkK6EhobSokVLTpw8wZCFnlSp5Sx3JKUpVbEK+YuVkDuGgPjkJgiCGn3//p169etz6vRpRnqsS1eFDX7cFlC7VQcAAgIC5A2TwYniJgiCWnz58oXatetw9do1xq7aQrnqNeSOpBLWdRsAsGrVKpmTZGyiuAmCoHLv37+nhoMDPg8fMmHtDkpVrCJ3JJXR1TMAYP2GDQQHB8ucJuMSxU0QBJV69eoVdvb2PH/5iknrvShiUU7uSGrxLSiIzZs3yx0jwxLFTRAElQkICMDWzo6PX4Jw37ibAsVLyh1JbcrbObBo0WIkSZI7SoYkipsgCCrx6NEjbKpXJywqBvdNe8hdqLDckdSqdquO+Pjc49y5c3JHyZBEcRMEQem8vb2xtbNDS9+QyZv2YJYnr9yR1K5MZWvyFS7KosVitQA5iOImCIJSXb16FfsaNTA2zcGkjbvIapZD7kiy+LFagCv79u7l+fPncsfJcERxEwRBac6dO4djzZrkLFSECet2Ypw1m9yRZGXfuCX6hoYsW7ZM7igZjihugiAoxdGjR6lbty6FLcozbtVWDDMZyx1JdvqGhtRo2hrPlSsJDQ2VO06GIoqbIAgptnv3bho1aoRFNVtGLV+PnoGB3JFSjbrtXPj08SPbt2+XO0qGIoqbIAgpsmnTJlq1akXl2s4MXbQKHV09uSOlKrkLmlPBzlHcFqBmorgJgpBsa9eupVOnTtg3acnA2UvR0taWO1Kq5NyhC7du3eTy5ctyR8kwRHETBCHZBg0ahHOHLvSePAdNTU2546Ra5arXIHdBcxaL2wLURhQ3QRCSRJIkZsyYAUDjLr3pMtodDQ3xVvI7GhoaOLVzwcvLi9evX8sdJ0MQr0hBEBJNkiSGDRvG9OnTAWjZZzAKhULmVGmDQ9NWaOvosmLFCrmjZAiiuAmCkCgxMTH06tWLuXPn0mnYOLnjpDmGmYyxb9KC5StWEBERIXecdE8UN0EQ/igqKorOnTuzatUq+k6dR53WHeWOlCY5t+/Cu8BAdu7cKXeUdE8UN0EQfis8PJyWrVqxdds2Bs31wLF5G7kjpVl5CxfF0tqORYvEwBJVE8VNEIQEhYSE0KhRYw4fPszwxauxcW4kd6Q0z7mDK1evXuHatWtyR0nXklXcli5dSsGCBdHT06NKlSpcvXr1t/svWLCA4sWLo6+vT758+Rg8eDBhYWHJCiwIgnoEBQVR19mZ8xcuMGr5Bio61JY7UrpQwb4WOfLmE7cFqFiSi9v27dtxc3NjwoQJ3Lx5E0tLS5ycnHj37l28+2/ZsoWRI0cyYcIEHjx4wOrVq9m+fTujR49OcXhBEFTj06dP1KxZi5u3bjN21RbKVrOVO1K6oampiVNbF7Zv357g+6aQckkubvPmzaN79+64urpSqlQpli9fjoGBAWvWrIl3/0uXLmFjY0O7du0oWLAgderUoW3btn/8tCcIgjwCAwOxt6/BYz8/Jq7bQYkKleSOlO44Nm+DQkMTT09PuaOkW1pJ2TkiIoIbN24watSo2G0aGhrUqlUrwWllrK2t2bRpE1evXqVy5cr4+/tz+PBhOnZMeLRVeHg44eHhsf8OCgoCIDIyksjIyKREjvXzuOQen56Jc5OwjHZuXr16RcNGjfgUFMTkDbvIa14EoqN/3fHntvh+ltEl4txkymSMY9OWrFm7Fjc3N7QzwLRlyvpdSuzxCikJM3m+fv2aPHnycOnSJapVqxa7ffjw4Zw7d44rV67Ee9yiRYsYOnQokiQRFRVFr169fru+0cSJE5k0adIv27ds2YKBmG1cEAQhwwoJCaFdu3Z8/foVY+OEl1VK0ie35Dh79izTpk3Dw8ODKlWq8OTJEwYOHMjkyZMZNy7+G0FHjRqFm5tb7L+DgoLIly8fderU+e2D+Z3IyEhOnDhB7dq1M8RfSUkhzk3CMsq5efjwIY0aN0ZTV58RHmvJliP37w+IjkbT/zbR5uVAzCkZVxLOzdQe7cmso8WxY0fVk01Gyvpd+nkl70+SVNyyZ8+OpqYmgYGBcbYHBgaSM2fOeI8ZN24cHTt2pFu3bgBYWFgQHBxMjx49GDNmTLxz0unq6qKrq/vLdm1t7RS/wSijjfRKnJuEpedzc/PmTeo4OZEpmymjV20lS3bTxB+sqSmKW0IScW4cW3ZgzqAe+Pj4UK5cOfXkkllKf5cSe2ySBpTo6OhgZWXFqVOnYrfFxMRw6tSpOJcp/y0kJOSXAvZz9nCxtpEgyOvSpUs4ODpikisvE9d7Ja2wCSlWuVZdsufMzaJFi+SOku4kebSkm5sbK1euZP369Tx48IDevXsTHByMq6srAJ06dYoz4KRhw4YsW7aMbdu28fTpU06cOMG4ceNo2LChWCJDEGR0+vRpatepQ75iJRm/djuZsmSVO1KGo6mlRZ02ndi6dSsfP36UO066kuTv3Fq3bs379+8ZP348b9++pVy5chw9epQcOXIA8Pz58zif1MaOHYtCoWDs2LG8evUKU1NTGjZsyNSpU5X3KARBSJKDBw/SokULSlWqxrDFq9DVFwO15FKrVXu8ls1n1apVjBgxQu446UayBpT069ePfv36xfuzs2fPxu1AS4sJEyYwYcKE5HQlCIKS7dixg/bt22PlUJvBcz3Q1vn1+21BfTKbZMPauTFLPTwYOnSouKKlJGJuSUHIQNauXUvbtm2xdm7EkPkrRGFLJep16MKL5885cOCA3FHSDVHcBCEDCA8Pp27dunTt2o1i5azoP3MRmloqvxNISKTCZcpSonxFFon5JpVGFDdBSOfu3LlDpUqVOXbsGCjg0e0beE4aKXcs4T/qtnflzOnT+Pj4yB0lXRDFTRDSqaioKKZNm0alSpUI/PQZhUID46wm1GjckhPbNzGiZT0ixYrQqUbVOvUxMTVjyZIlckdJF0RxE4R06PHjx1SvbvvjthvXXlja2CNJMeQrUoy+0+bhMnIifvfu0NOxEh/fvpE7rgBo6+hQu3VH1m/YwJcvX+SOk+aJ4iYI6UhMTAxLliyhXLlyvHgbyJTNe2nvNoorJ48AUKpiVRQKBQ1dejDGcxNhwcH0r1udu39fkDm5AFC7dUciIyNZu3at3FHSPFHcBCGdeP78ObXr1KF///7UaNaG2XtOULx8Rd69esG3z58AqFyzbuz+5W0dmLXrCJmzZ2dyt3bsW7NcrujCP7KamlHNqQFLli4lJiZG7jhpmihugpDGSZLE+vXrKWNhgbfPA8av2Ua3cVPR+2cFjZ0eC5AkCS1tHQqVKhPn2LzmRZnldZRSFauwYfZk5rn1kuMhCP9Sr0MX/P38OHLkiNxR0jRR3AQhDQsMDKRJ06a4uLhg5eDEvP2nsLS2i7PP9TPHATAyzhxvG5myZGXcqq3Ua+/KxcP7GdTAgbCQEJVnF+JX1LICRcpYsmiRuC0gJURxE4Q0ateuXZQuU4a/Llxk+JLV9J+5EMP/FLBXT58Q9M8lydzmhRNsS1NLi65jp9DLfTav/J/Q06EibwL8VZpfiJ9CocC5QxeOHz/Go0eP5I6TZoniJghpzOfPn+nYsSMtWrSgSPlKzNt/miq1nOPdd+fS+fDP6hslrar8se3ardozcf1OJElicKOaXDmZ/tcZS41s6jUiS7bsLF26VO4oaZYoboKQhhw/fpwyFhbs2bef/jMXMWzRKjJny57g/rfOn4n9/5Vr1U1wv38rXakqs3cfI0e+AswZ2J2ti2anOLeQNNo6utRs2Z6169bx7ds3ueOkSaK4CUIaEBwcTO/evXFycsK0YGHm7T9FjcYtUCgUCR7z9P49vn/9QlbTHGhpa2NeyiLR/eXIm58Z2w9Swb4mXh7zmdqjgxi9p2ZObToSGhLC+vXr5Y6SJoniJgip3MWLFylracm69RvoPn4a41ZtJXuuPH88zmv5AjQ0NcmeKzeGxpnjXfX+d/SNjBixZA3Neg7g5l+n6edkw/egr8l9GEISZcuZm8q1nFm8eIn4wyIZRHEThFQqPDycESNGYGtri05mE2bvOU7ddi6//bT2b96XL1DOxp43z56Su1DCg0l+R0NDg/aDRzJo9hI+vn1NL8fKPL1/L1ltCUnn3KELjx8/4uTJk3JHSXNEcROEVOjWrVtYWVVk/oIFtHcbhfvG3eQuaJ7o4x/duk7ItyBKVarK969fKFG+Yory2DZsxtQt+9DR1WVk6/pcOLwvRe0JiVOqYhUKliglbgtIBlHcBCEViYqKYsqUKVSuXJmQaImZO4/QtHu/JC9guWv5IjS1tMmWMzeQ+MEkv1PEohxzdh8nf9ESrJgoVoxWB4VCgXN7Vw4fPoS/v7g1IylEcROEVOLhw4dYW9swYcIEGnfry/QdhyhQvGSy2rp//TIVa9Ti9VM/tLS1KWJRXikZTXLkZMqWvVStXQ8A925tiYqKUkrbQvxsGzTFyDizuC0giURxEwSZxcTEsHDhQsqXL8/rDx+ZunU/7QaNQFtHJ1nteV86T2hwMNUbNMHPxxuDTMZJHkzyO7p6+vSZMheAx3du0tuxMp/fv1Na+0JcuvoGOLZoy+o1awgODpY7TpohipsgyOjZs2fUrFWLQYMG4diyPbN3H6OYZYUUtbln1RJ0dPWwsq/Jk7u3yVUg8d/VJdbPQS1ucz34HvSFvnWseXDzmtL7EX6o29aFb0FBbN68We4oaYYoboIgA0mSWLNmDWUsLLj/yJeJ63bQdcxkdPUNUtz2o1vXqVzLiZBv3wj69JESFVI2mOR3KtjVZOaOwxhlzsKETs05skUs1aIKZnnzUdGhNosWLUb6Z8YZ4fdEcRMENXv79i0NGzaia9euVK5djzn7TmJRtbpS2r5y8ijhoaFUr//jkiRApZopH0zyO/mLlWDOnmMUs7Ri9eSxLB45UKX9ZVTOHbrg43OPc+fOyR0lTRDFTRDUaOfOnZQuU4aLf//NSI+19J02H8NMxkpr/8C6FegZGFKueg38fbzR1NKieDkrpbWfEOOs2Ziwdju1WrXn7N6dDGlam4iwMJX3m5FYVK1O/iLFWLRY3BaQGKK4CYIafPr0iXbt2tGqVSuKV6zG/INnqOTopNQ+YmJi8Lt7h2pO9dHW0cXPxxtDJQ8m+R1tHR16TpxJt3FTefboAT0dfiyUKiiHQqHAqb0r+/bu5fnz53LHSfVEcRMEFTty5AhlLCw4cOgwg2YvYciCFRhnzab0fi4e3kdEeBg29RoD4Ot9i5z5Cyq9n9/5eV/W+NVbiYyMZGA9e27+dVqtGdIz+0Yt0Dc0YtmyZXJHSfVEcRMEFfn+/Ts9evSgXr165DQvxrwDp7Ft2CzR02cl1aENqzDIZIxF1ep8+fCerx8/ULx8JZX09Sdlq9kyy+sI2XLmYnrvzuxasUiWHOmNvqEhDs1a47lyJaGhoXLHSdVEcRMEFTh//jwWZcuyafMWek6cyZiVm8mWI5fK+ouJiSHg4X2q12uMlrb2vwaTKPfSZ1LkLmjOTK8jlK1my5b5M5jZr6uYAFgJ6rZz4fOnT2zbtk3uKKmaKG6CoERhYWEMHToUe3t79LNmZ87eE9Rp01Fln9Z+Or1rK5ER4Vg7NwLg6f27aGppUdKqskr7/RPDTMaMXrGRRl16cfXkEQbWtyfku1ifLCVyFShEBTtHcVvAH4jiJghKcuPGDSpYWbFo8WI6DB3DpI271fad15Et6zDOakKpSlUBeHLvDgZGmdQ2mOR3NDU16Tx8PP2mLyDwxTN6OVbixZNHcsdK05w7dOH27VtcunRJ7iiplvyvfEFI4yIjI3F3d6dq1aqEo8Esr6M06donyZMdJ7v/iAhePnlM9fpNYvt8IsNgkj9xaNoK9w270NDUYmgzJy4d2S93pDTL0sae3AXNWSxuC0iQKG6CkAIPHjygmrU17u7uNOnRj2nbDpK/WAm1Zji2bQNRkZGxoyS/fvrI5/fvKKaG+9uSqkSFSszZfYw8hQozf0hfNs6ZKnekNElDQ4O67VzYtWsXr1+/ljtOqiSKmyAkQ0xMDPPmzaN8+fIEfv7KtG0HaDtgeLInO06Jkzs2YWKWM7aY+f8cTOJYR+1ZEiN7rjxM23qAyrWc2LtqKRNdW4mBJsng0Kw12rq6LF++XO4oqZIoboKQRE+fPqWGgwNDhgyhdptOzNp1lCIW5WTJEhEWxusAf6o3aBL7/Zq/z100NDUpXdlalkyJoWdgwJAFnrTuN4S7ly/Qu1YVgj59lDtWmmJglAn7xi1ZvmIF4eHhcsdJdURxE4REkiSJlStXYlG2LI/8njJpvReuoyahq6cvW6YD6z2Jjoqier0msdv8fFLPYJLf0dDQoFW/IQxduJKvHz7Qp3ZVnnjfkjtWmuLcwZX3796xc+dOuaOkOqn71S8IqURgYCD16zegR48eVK3bkLn7TlKmivyfjM7s2Y5ZnnyYl7aI3eZ75xY58hWQMVXSVHOqz/TtB9AzNGJM+yac3CmWdUmsvOZFsbS2Y9EiMbDkv0RxE4REqFylCleuX2fUsvX0mTIXA6NMckci5HsQ7168iDPrybfPn/j07q1aJktWpkIlyzBn93HMS1mwfMIIlk8YLnekNMO5gyvXrl3l6tWrckdJVURxE4QEfPz4ERdXVwCKV6zKvP2nqehQW+ZU/7d31TKio6Oo/s8oSQD/+3cBsEpFORMrS3ZT3DfuokbjlpzYvomRreoTGREhd6xUr4J9LXLkzSduC/gPUdwEIR6HDx+mdJkynDh5CoD+0xeSKauJzKniOn9gN7kLFo5z64GfjzcampqUqWIjY7Lk09bRpe+0eXQeMYEnd2/T07ESH9++kTtWqqapqYlTWxe2b99OYGCg3HFSDVHcBOFfvn37Rrdu3ahfvz55ipVi+vaDckeKV9DnT3x4+xq7Rs3ibPe7542BUSa0tLRkSpZyCoWCRq49Gb1iI2HBwfSvW527f1+QO1aq5ti8DRqaWnh6esodJdUQxU0Q/nHu3DksypZly7Zt9HKfzegVG8lqmkPuWPHa7bmEmOhobP6ZS/InX+9bmOXNL1Mq5apg58gsryNkzp6dyd3asX/tCrkjpVqZsmTFtmEzli1fTmRkpNxxUgVR3IQMLzQ0FDc3NxwcHDAyzcmcvSep3aq9yic7TolLh/dRoHhJchcqHLvt25fPfHz7mmKW5WVMplx5CxdlltdRSlWswoZZ7sxz6y13pFSrXocuvHn9mj179sgdJVUQxU3I0K5fv075ChVY6uFBp+Hjmbjei5ypfBj9p8C3fHofiF3DuJcknz64B4BVjbQ3mOR3MmXJyrhVW6nb3pWLh/cxqIEDYSEhcsdKdQoUL0mZytXEbQH/EMVNyJAiIyOZMGECVatWJVpLh1m7jtHItWeqv/EZYNeKhUgxMVjXjXtJ0v+fwSRlre1kSqY6mlpadBs7hV7us3nl/4SeDhV5E+Avd6xUp277Lly8eIHbt2/LHUV2qf83WRCUzMfHhypVqzJ16lRa9B7E1K0HyFekmNyxEu3v44cpYlEOs7z54mz3u+eNvqFRmh5M8ie1W7Vn4vqdSJLE4EY1uXb6uNyRUpXKNZ0wzZWHRYvEyueiuAkZRnR0NHPmzMHKyoqPQd+Zvv0QrfoNQUtbW+5oiRb44hlfP37A9j+XJOGfwSR58sVzVPpSulJVZu8+Ro58+ZnVvyvbF8+RO1KqoamlRZ02ndi6dSsfP2bsuTpFcRMyBH9/f2o4ODB8+HCc2rkwc9dRCpcpK3esJPNathAJsHZqEGd7cNBX3r9+SVHLCvIEU7McefMzY/shKtg5smPpPKb26CBWFvhHrVbtiJEkVq1aJXcUWYniJqRrkiSxYsUKLMqWxfdpAJM27KLziAno6OrJHS1Zrp85TskKlTDJkTPOdv/7/wwmsa8pRyxZ6BsZMWLpWpr1HMDNv07Tz8mG70Ff5Y4lO+Os2bCp15ilHh5ERUXJHUc2orgJ6darV69wdq5Hr169sKnflLl7T1G6UlW5YyXbCz9fgr58jveSpL+PNxoamlja2MuQTD4aGhq0HzySQbOX8PHta3o5VubpP4U+I6vXoQsvnj/nwIEDckeRjShuQrojSRJbtmyhdJkyXLt1i9ErNtLLfRb6RkZyR0sRL4/5KBQKqtap/8vP/Hy80Tc0lGWx1NTAtmEzpm7Zh46ODiNb1+fcvl1yR5KVeemylKhQiUUZeL5JUdyEdOXDhw+0bNWK9u3bU9amBvP2n043l+puXziLRVUbMptk++Vnvt43Mc2TV4ZUqUcRi3LM2XOC/EVLsHjUQNZMHSd3JFk5t3fl7Jkz3LuXMT/JiuImpBsHDhygdJkyHD95Crf5yxk014NMWbLKHUsp/H3u8v3rF6rXb/LLz0K+f+PdyxcUsUg/M5Mkl0mOnEzZshcb50Yc2riasR2aZtjvnarWqY+JWQ6WLFkidxRZiOImpHlBQUG4urrSqFEj8pW0YP7+07/MuZjW7Vy2AA1NTarUcv7lZz+/Y6pg56juWKmSrp4+g+Yspb3bKB7cuEpvx8p8fv9O7lhqp6WtTe3WHdmwcSOfP3+WO47aieImpGlnzpyhjIUF23fupM/UuYxatp6sZqlzsuOUuHflIuVtHTDKnOWXn/n5eKPQ0KC8rYP6g6VSCoWCZj36M3LpGr4HfaFvHWse3Lwmdyy1q92qA5GRkaxdu1buKGonipuQJoWEhDBw4EAcHR3JnDMP8/adpmbztql6suPkenD9CiHfguK9JAk/RkrqGxqho5c2b29QpUqOTszYfgijzFmY0Kk5R7ZkrDf5rKZmWNdtyJKlS4mOjpY7jlqJ4iakOVeuXKF8hQosX+GJ66hJTFi385epqNKT3Z6L0dLWppJDnXh/7ut9C9NcedScKu0oULwkc/Yco5ilFasnj2XxyIFyR1Ir5w5deOrvz5EjR+SOolaiuAlpRkREBGPHjsXa2hpJR5/Ze47RoHP3NDHZcUrcv3EFqxq1472VIfT7d96+eEZhC0sZkqUdxlmzMWHtdmq1bMfZvTsZ2rQOEWFhcsdSi6Jly1OkjGWGWy0gfb8rCOnG3bt3qVy5CjNmzqRVvyFM3bqfvOZF5Y6lcrcvnCUsOBjbBC5JPn3oA5JEeTGY5I+0dXToOWkWXcdOIeDRfXo6VOTdqxdyx1I5hUKBc4cunDhxnEePHskdR21EcRNStejoaGbOnEnFihX5HBLKjO0HadlnMJrpeOb7f9u7ygMdPT0q2MdfvPz/GUxS0b6WmpOlTQqFgnodujB+9VYiIyMZWM+e2+fPyB1L5WzqNSJLtuwZ6rYAUdyEVOvJkyfY2dszatQonDt2ZabXEcxLp73JjlPi8Z0bVK5ZF119g3h/7ufjjb6BoRhMkkRlq9kyy+sI2XLmYlqvTuxakb6XiNHW0aVmy/asXbeOoKAgueOoRbKK29KlSylYsCB6enpUqVKFq1ev/nb/L1++0LdvX3LlyoWuri7FihXj8OHDyQospH+SJLFs2TIsLS3xf/6SyZt202nYuDQ72XFyXTlxhPDQ0ARHSQI88b5F9ly51RcqHcld0JyZXkewqFqdLfNnMLNf13S9soBTm46EhYayYcMGuaOoRZKL2/bt23Fzc2PChAncvHkTS0tLnJycePcu/pskIyIiqF27NgEBAXh5efHo0SNWrlxJnjxidJfwq5cvX+LkVJc+ffpQvVEL5uw9SUmrKnLHksX+dSvQNzSiXPX4J0MOCwnhzbOnGe7TrDIZZjJmtOcmGrn25OrJIwysb09o8He5Y6lEtpy5qVK7HosXL0nXRfynJBe3efPm0b17d1xdXSlVqhTLly/HwMCANWvWxLv/mjVr+PTpE3v37sXGxoaCBQtib2+PpaUY3SX8nyRJbNq0idJlynDT25uxK7fQc+IM9A0N5Y4mi5iYGPzveVPNqT7aOrrx7hPw8B6SGEySYpqamnQeMYF+0xcQ+OIZPR0q8uJJ+hx44dyhC48fP+LkyZNyR1G5JH0rHxERwY0bNxg1alTsNg0NDWrVqsXly5fjPWb//v1Uq1aNvn37sm/fPkxNTWnXrh0jRoxAU1Mz3mPCw8MJDw+P/ffPa8SRkZFERkYmJXKsn8cl9/j0TO5z8+HDBwYNHsyB/fuxcW5Ex2FjMTLOAqnhptOfGdSc5fKRfWhqKLCt3zjBvp/dv4eBoSEV7RzVf65kOi+q5NCoOXkKFGSeW2/Gt29Cr0mzqFK7XtIbSsXnpmQ5K0pYVmDZsuU4OKh3Rhtlvc8k9niFJElSYht9/fo1efLk4dKlS1SrVi12+/Dhwzl37hxXrlz55ZgSJUoQEBBA+/bt6dOnD0+ePKFPnz4MGDCACRMmxNvPxIkTmTRp0i/bt2zZgoFB/F+sC4IgCOlfSEgI7dq14+vXrxgbGye4n8rHU8fExGBmZoanpyeamppYWVnx6tUrZs+enWBxGzVqFG5ubrH/DgoKIl++fNSpU+e3D+Z3IiMjOXHiBLVr10ZbWztZbaRXcpyboKAgRowYwZYtW6hg70jX0VPInC27WvpOkuhoNP1vE21eDhK40qBsMTExdK1eFtuGzeky6tc/8n4a3qIuCoUGM3fKMDhLhvOiTmGhIayYMJxrp49TunI1RixZm/jJAlL5uQkPD2VgPXtcOnZg6tSpautXWe8ziR3tmaTilj17djQ1NQkMDIyzPTAwkJw5c8Z7TK5cudDW1o5zCbJkyZK8ffuWiIgIdOJZXFFXVxdd3V+/Z9DW1k7xm68y2kiv1HVuTp06hYurK58+f6bLuGk4NG2V+ueE1NRU2xvVKa+tBH39SpU69RPsMzw0BP+H97Ft2FzeN1A1nhd10jPKRP/ZS/HymM/2JXPp42TDLK8jGMezll6CUum50TUwwqZBUzxXrmTChAkYqvl77ZS+zyT22CQNKNHR0cHKyopTp07FbouJieHUqVNxLlP+m42NDU+ePIkzOufx48fkypUr3sImpF8hISH079+fWrVqkTV3fubuO41js9apv7Cp2dGt6zA2yUYJq8oJ7hPw8P6PwSS28Y+kFFJOQ0ODVv2GMHSBJ18+vKNP7ao88b4ldyylcGrrwregIDZt2iR3FJVJ8mhJNzc3Vq5cyfr163nw4AG9e/cmODgYV1dXADp16hRnwEnv3r359OkTAwcO5PHjxxw6dIhp06bRt29f5T0KIdX7+++/sbQsh+fKVXQdM5nxa7djlsFXjo5PZEQEL/18sW3QNMEBV/DPMjcKBZUcndSYLmOqVrcB07YdQM/QiDHtm3DSa6vckVLMLE9eKjrWYdHixSRh2EWakuTi1rp1a+bMmcP48eMpV64ct2/f5ujRo+TI8WMNrefPn/PmzZvY/fPly8exY8e4du0aZcuWZcCAAQwcOJCRI0cq71EIqVZ4eDijR4/GxsYGDcNMzNlznHodu6b7yY6T6+iWdURFRv5xsdWn9++iZ2CIvuGvkykLymdeyoI5u49TqGQZlo8fxoqJaf/9q16HLtz38eHs2bNyR1GJZA0o6devH/369Yv3Z/GdqGrVqvH3338npyshDfP29qZDh448ePiANgOG06RbnwwzJ2Ryndy5GZMcOSlWzuq3+z32voVJjvi/5xZUI0t2UyZv2s2K8SM4vm0DT+/fZfKmPWin0a9XylSxoUDR4ixavFjttwWog/jzWVC6qKgopk+fTsWKFfkWEcmMHYdo3muAKGx/8HPGEbuGzX77PWR4WCiv/J9gXspCjekE+DFHY9/p8+k8YgJP7t6ml2MlPr598+cDUyGFQoFTe1f279vHs2fP5I6jdKK4CUrl6+tL9eq2jB07lgYuPZmx8zCFSpaRO1aacHD9SqKjov54SfLZowdIMTGUq15DPcGEOBQKBY1cezJ6xUZCg4PpX7c6965ekjtWstg1bI6+oRHLli2TO4rSieImKEVMTAxLlizB0tKS52/eMnnTHjoMGZ3g1FHCr87s2Y5Z3vwU+sMnMv/7d1EoFFSuJQaTyKmCnSOzvI6QOVt23F3bsH/tCrkjJZm+oSEOzdrguXIloaGhcsdRKlHchBR78eIFdeo40b9/f+ybtmLO3pOUqFBJ7lhpSsj3IN69eoFdo99fkoQfa7jpGRhiYJS8CQ0E5clbuCizdh2lZMUqbJjlzjy33nJHSjLn9i58+fyZrVvT/ijQfxPFTUg2SZJYv349pcuU4Y6PD+NXb6X7+OnoiSnSkmzvKg9ioqOxcW78x31979wiq6mZGlIJiZEpS1bGrdpC3fauXDy8j1Gt68sdKUly5i9IBfuaLFqUvm4LEMVNSJZ3797RtFkzXFxcqOBQh3n7T2NpI24oTq6/Duwmj3kR8hct/tv9IsLDeOnn+8dLl4J6aWlr023sFHpOmsWrp/4AvH3+VOZUiefcvgt37tzm4sWLckdRGlHchCTbvXs3pUqX5tz5CwxfvJoBMxdhaJxZ7lhpVtCnj3x88wa7hs3+uO/zxw+JiYlOcI03QV51Wndg1LL1AIxq24hrp4/LnChxLG3syF3QnEWLF8sdRWlEcRMS7cuXL3Ts2JHmzZtTpFxF5u0/TZXaznLHSvN2eS4mJiYa6z+MkgTw97kLCgWVa4nznlqV/GfaNLPceZnVvyvbF8+ROdGfaWhoULedC7t37eLVq1dyx1EKUdyERDl+/Dily5Rhz7599J+xkGGLV6fOWfzToEtHDlCwRGlyFzT/475+Pt7o6RtgJD4pp3oT1+2kgp0jO5bOY2rPjql+9WuHZq3R0dNj+fLlckdRClHchN8KDg6md+/eODk5YVqgMPP2n6ZGk5ZismMl+fj2LZ/fB2LbsGmi9vf1FoNJ0gp9QyNGLF1Lsx79uXnuFP2cbPge9FXuWAkyMMqEfeOWrPD0jLNYdFolipuQoIsXL1LW0pK169bTbdxUxq7aQvZceeSOla7sWr4AKSYG67p/viQZGRHOiyePxE3xaYiGhgbt3UYxaPYSPrx5TS/Hyjy9f0/uWAly7uDK+3fv2Llzp9xRUkwUN+EX4eHhjBw5Ejs7O3SMszJn7wmc27uKyY5V4MrJIxS1rJCoFRJe+D4iJjoaSxs7NSQTlMm2YTOmbd2Hjo4OI1vX59y+XXJHilde86JY2tixaFHaH1gi3q2EOG7fvo2VVUXmzptH20EjcN+0J1HfBQlJF/jiGV8/fsC2fpNE7e/ncxdADCZJo4pYlGPOnhPkL1qCxaMGsmbaeLkjxcu5fReuXbvK1atX5Y6SIqK4CbHmzJlDpUqVCI6OYabXEZr16P/bNcWElNnpMR8JsK7bMFH7/5iZxADjrCaqDSaojEmOnEzZshdr54Yc2rCKsR2aEhUVJXesOCrY1yRnvvwsTuO3BYjiJuDr6wvA1KlTadS1DzN2HKZg8VIyp0r/rp89SSmrymQ1y5Go/X29b5E5mxhMktbp6ukzeI4H7QeP4sGNq/R2rMzn9+/kjhVLU1MTp7YubN++ncDAQLnjJJsobhlYTEwMixYtonr16gCMX72V9oNHptn1qdKSF08e8e3zJ2wb/PnGbfixQvdz34cUKllaxckEdVAoFDTr2Z+RS9fwPegLfetY8+DmNbljxXJs3gZNLW08PT3ljpJsorhlUM+ePaNmrVoMHDgQu8YtAShiUV7mVBnHTo8FKDQ0qOpUL1H7v/R7THRUFGWtbVWcTFCnSo5OzNh+CKPMWZjQqTlHt6yTOxIARpmzYNuwGcuWLycyMlLuOMkiilsGI0kSa9eupYyFBT4PHzNh7XY6DRsnd6wM586Fs5StWh3jrNkStb+fjzcAVWonrhgKaUeB4iWZvfsYRS0rsGryGBaPGiR3JACc27vy5vVrdu/eLXeUZBHFLQN5+/YtjRo3pkuXLlSq5czc/acoW018ElC3J/fu8D3oK9UbJO7Gbfgx7ZauvgFZxKww6VJmk2xMXLuDWi3bcXbPDoY2rUNEWJismQoUL0mZytZp9rYAUdwyCC8vL0qXKcOFS5cZsXQN/aYvwDCTWA9MDruWLURTS4sqteom+hhf71uisKVz2jo69Jw0i65jpxDw6D49HSvx7tULWTM5d+jCpUsXuXXrlqw5kkMUt3Tu8+fPtG/fnpYtW1KsQhXmHThD5ZqJf1MVlO/elYuUt3VI9EoKUZGRPHv0gAIlxGCS9E6hUFCvQxfGrdpCZHg4A+vbc/v8GdnyVHKsg2muPCxatEi2DMklils6dvToUUqXKcO+AwcZMGsxQxetJLNJ4r7jEVTD59rfhHz/RvVE3rgN8NLfl+ioSMpWq666YEKqYmltx6xdR8mWIxfTenVi1wp5ioumlhZ12nZi69atfPjwQZYMySWKWzr0/ft3evbsibOzMznMizL/wGnsGzUXkx2nAns8F6Olo0NFhzqJPsb/3o/BJFXrpK0VnoWUyV3QnJleR7CoWp0t82cws19XWVYWqNWyHRKwatUqtfedEqK4pTPnz5+nrKUlGzZuovuE6YxduYVsOXPLHUv4x4MbV6nkUAd9Q8NEH+Pn442uvr5YDSADMsxkzGjPTTRy7cnVk0cYWN+e0ODvas1gnDUb1es3YamHR6qbTeV3RHFLJ8LCwhg2bBj29vboZcnGnL0nqNu2s/i0lorc/Os0YSHBSbokCfDk7m0ym4jBJBmVpqYmnUdMoO+0+QS+eEZPh4q8ePJYrRmcO3Th5YsX7N+/X639poQobunAzZs3sapYkYWLFtFhyGgmbdxNrgKF5I4l/Me+1R7o6OlR3s4h0cdER0Xx7NF9Cojp0DI8x2atcd+wCw0NTYY1q8OlYwfV1rd5KQtKVqjEojQ036QobmlYZGQk7u7uVKlShbAYBTN3HqFJt75isuNUKCYmBt87t6haux66evqJPu6V/xMiIyIoU1UMJhGgRIVKzN59jNwFCzN/cG82zZ2qtr6dO3Th3Nmz3L17V219poQobmnUgwcPqGZtjbu7O02692Pa9oMUKF5S7lhCAq6cOEJ4WCg29Ron6bifM5NUqyNmJhF+MM2dl2nbDlCpZh32rFzKJNfWahloUqV2PUzMcrBkyRKV96UMorilMTExMcyfP58KFSoQ+OkLU7fup+3A4WKy41TuwDpP9A2NsLSxT9Jx/j7e6Orpky1nLhUlE9IiPQMDhi5cSet+Q/C+fJ4+taoS9OmjSvvU0tamduuObNy0ic+fP6u0L2UQxS0NCQgIwMHRETc3N2q26sCsXUcpWlZMdpzaxcTE8PS+N9bODZP8R8iTu7cxFvcmCvHQ0NCgVb8hDF3gyZcP7+hTuypP7t1RaZ+1W3UgMjKStWvXqrQfZRDFLQ2QJIlVq1ZRxsKCh75+TFy3ky6j3dHVN5A7mpAIf+3fRUR4ODbOjZJ0XHR0NE8f+JC/WAkVJRPSg2p1GzBt2wH0DI0Y07YRJ722qqyvrKZmWNdtyJIlS4mOjlZZP8ogilsq9+bNGxo0aEj37t2p4tSAuftPYVHVRu5YQhIc3rQGo8xZKFMlac/b66d+REaEJ/k4IeMxL2XB7F3HKFSyDMvHD2PFxJEq68u5QxeePvXnyJEjKutDGURxS8W2b99O6TJluHz1KiM91tF36jwMjDLJHUtIgqioKJ4/foBNvcZoamkl6djYwSR1G6gimpDOZDU1Y/Km3dg3as7xbRsY2boBkRERSu+nmGUFilqUS/WrBYjilgp9/PiR1m3a0KZNG0pUsmbegdNUckz8dE1C6nFq5xYiIyKSPEoSfgwm0dHTwzRXHhUkE9IjbR1d+k1fQOfh43nifYtejpX4+PaN0vup26ELJ04c59GjR0pvW1lEcUtlDh8+TOkyZThy9BiD5ixlyIIViV7QUkh9jm3bQOZs2SlpVTnJx/rdvYNxVhMVpBLSM4VCQaMuvRi9YiOhwcH0d67OvauXlNqHjXNDsmTLnqpvCxDFLZX49u0b3bt3p379+uQuWpJ5+09j26CpmD4rDYuMiOCVvy+2DZqioZG0X7WYmBj8H9wlf1ExmERIngp2jszyOkJmk+y4d2nD/rWeSmtbW0eXWq06sHbdOoKCgpTWrjKJ4pYKnDt3DouyZdm8ZSs9J81ijOcmTHLklDuWkEJHNq8lKjIyWZckXwf4EREWRukq1ipIJmQUeQsXZdauo5S0qsKGWZOYP6SP0tqu06YjYWFhrF+/XmltKpMobjIKDQ3Fzc0NBwcHDLPnYM6+k9Rp3UF8WksnTu7cTLacuZJ1L6K/z48pjqqJZW6EFMqUJSvjVm2hbjsXLhzay+CGDoSFhKS43Ww5clGltjOLFy+RZSmePxHFTSbXr1+ngpUVSz086DRsHBPXe5EzXwG5YwlKEhYSwtvnAdg2bJasP1b8fe6io6dHDvGaEJRAS1ubbuOm0nPSLF76PaGXQ0XeBPinuN16Hbrg6/uYEydOKCGlconipmaRkZFMmDCBqlWrEqmhxUyvozTq0ktMdpzOHFzvSXRUFNWTcUkSfsxMYpQlq5JTCRldndYdmLhuBzExMQxuXJNrp4+nqL0SFSpjXrJMqrwtQBQ3NfLx8aFK1apMnTqVZj0HMG3bQfIXLS53LEEFTu/eQY58BShYonSSj42JicH/vjf5i4jXhqB8pStXY/ae4+TIm59Z/buyfcncZLelUCio28GVI0cO4+fnp8SUKSeKmxpER0czd+5crKyseP/lG9O2HaDNgGFoaWvLHU1QgeBvQbx//QK7ZF6SfPvsKeGhoZSuXE0F6QQBcuTNz4zthyhv68COJXOZ2rNjsr83q16/CZmyZGXp0qVKTpkyoripmL+/PzUcHBg2bBi123Rm1u6jFLEoJ3csQYX2rlxKTHR0skZJwr+XuRGDSQTV0TcyYqTHOpr16M/Nc6fo52TD96CvSW5HV08fxxZtWb1mDd+/f1dB0uQRxU1FJEnC09MTi7Jl8X0awKT1XriOmpikhSqFtOmvg7vJW7go+YoUS9bx/vfvoqOrS66C5kpOJghxaWho0N5tFINmL+HDm9f0dqxMwMP7SW7HqU1nvn/7xqZNm1SQMnlEcVOB169fU69efXr27Il1vcbM3XtKXGLKIL58/MCnt2+wa9g82W08uXsHo8xiMImgPrYNmzF1y160dXQY0bIefx3YlaTjzfLkpVJNJxYvWYIkSSpKmTSiuCmRJEls3bqV0mXKcPXGDUYv30DvyXPQNzKSO5qgJrtXLCImJgabeklb3uYnSZLw9/FO9qc+QUiuomXLM3vPcfIVLcaiEQNZM218ko53bt+F+z4+nDlzRkUJk0YUNyX58OEDrVq3pl27dpSuZsu8/aexqlFL7liCml0+epBCJcuQM3/BZB3/9nkAYSHBlKokPukL6pctRy6mbtmHdd2GHNqwirEdmhIVFZWoY8tUsaZAsRIsWpw6bgsQxU0JDh48SOkyZTh24iRu85bhNm85mcSEtxnOx7dv+PzhHXYNmyW7Df/7P2YmqepUT1mxBCFJdPX0GTzXg/aDR/Hg+hV6O1bm84f3fzxOoVBQt50rB/bv59mzZ2pI+nuiuKVAUFAQXbp0oWHDhuQrUYb5+08ne4SckPbtXDYfKSYGa+eGyW7D38cbbR1d8poXVWIyQUgahUJBs579GbF0Dd+/fqFf7Wo8uHntj8fZNWqOvqERHh4eakj5e6K4JdOZM2ewKFuWbTt20HvybEYt30BWsxxyxxJkdPXUMYqVsyJ7CtZfe3L3NkaZsygvlCCkQOWadZmx4xCGmbMwoVNzjm39/STJegYGODRrw8pVqwgNDVVTyviJ4pZEoaGhDBo0CEdHR4xz5GbuvlPUatleTHacwb159pSgjx+wbdA02W1IkoTfPW/yFhGf2oTUo0DxkszefYyilhVY6T6aJaMG/XZ/5/YufPn8ma1bt6onYAJEcUuCq1evUq58eZYtX47LyIlMWLeTHHnzyx1LSAV2LlsAQDWnBsluI/Dlc0KDv1OqohhMIqQumU2yMXHtDmq2aMuZPTsY2syJiLCwePfNmb8gFexrsmjRYllvCxDFLREiIiIYN24c1tbWxGjrMXv3cRq69EjyApRC+nXz3ClKVapKVlOzZLfx9J9lbqrWEYNJhNRHW0eHXu6z6TpmMgEPfejpUIl3r17Eu69z+y7cuXObixcvqjnl/4l35z+4d+8eVapWZfqMGbToM5ipW/eTt7C4bCT837PHD/n2+RPV6yf/kiT8mHZLW0dHTKYtpFoKhYJ6HbsybtUWIiPCGVjfntvnf72vzdLGjjyFCst6W4AobgmIjo5m1qxZWFlZ8elbMNO3HaRVXzcx2bHwi13LFqChoUnVOs4pasfv3h0MjbMoJ5QgqJCltR2zdh3FxCwn03p1YveKuEVMQ0ODuu1c2L1rF69evZIloyhu8Xjy5Al29vaMHDmSuh26MHPXUQqXKSt3LCGVun3xHGWtbTHOmi3ZbUiSxJO7t8lbuIgSkwmC6uQuaM4sryNYVK3O5gUzmNW/W5yVBWo0bYWOnh7Lly+XJZ8obv8iSRLLli3D0tIS/+cvcN+4m87Dx6Ojqyd3NCGVeuJ9i+Cgr1Sv3yRF7bx//YqQ798oVbGqcoIJghoYGmdmtOcmGnbuwZUThxlY357Q4B8rAxgYZaJGk1as8PQkPDxc7dlEcfvHy5cvcXKqS58+fajesDlz9p6iVMUqcscSUjmv5YvQ1NKicq26KWrH/59lbirXStmlTUFQN01NTVxGTqDvtPkEvnhGT4dKvPDzBcC5vSvv371jx44das+V4YubJEls2rSJMhYW3PT2ZuzKzfScNBN9Q0O5owlpgM/VS5S3c8Qwk3GK2vHz8UZLW4dCJZO+crcgpAaOzVrjvmEXGhoaDGtam0vHDpLHvAjlqtuzaJH6B5Zk6OL2/v17mrdoQceOHSlrU4O5+05R3tZB7lhCGuFz9TIh379hm8JLkvBjMImRceaUhxIEGZWoUInZu4+Rq2Bh5g/uzaa5U3Fu34Xr169x/fp1tWZJVnFbunQpBQsWRE9PjypVqnD16tVEHbdt2zYUCgVNmjRJTrdKtW/fPkqXKcOpM2cZsmAFg+Z6kCmLWENLSLzdnovR1tGlokOdFLXzczBJbvPCSkomCPIxzZ2X6dsOUKlmHfasXMrBDSvJkTcfK1asUGuOJBe37du34+bmxoQJE7h58yaWlpY4OTnx7t273x4XEBDA0KFDsbW1TXZYZQgKCsLFxYUmTZpQoHRZ5u0/jXXd5E90K2RcD29eo6JjbfQMDFLUzse3rwkO+kpJK/Edr5A+6BkYMHThSlr1dePu5Qt8ePuG3bt3qzVDkovbvHnz6N69O66urpQqVYrly5djYGDAmjVrEjwmOjqa9u3bM2nSJMzNzVMUOKWqVqvGzl276DN1LiM91qdoRgkh47px7iRhIcHYpvDGbfjxfRtAFTGYREhHNDQ0aN1/KEMWrEBDQ4OYGPVOxaWVlJ0jIiK4ceMGo0aNit2moaFBrVq1uHz5coLHubu7Y2ZmRteuXTl//vwf+wkPD48zdDQoKAiAyMhIIiMjkxI51o0bNwAwNs3B0GUbMc2VB/51T0aGFh0d93+F/0vg3BzduJosJiaUr26X4vP24uF9MhkbU6h4ybTzHIjXTMLEuYnDunY99Bfr4/HPhMvJfQ//KbHHK6QkzGz5+vVr8uTJw6VLl6hW7f+Tuw4fPpxz585x5cqVX465cOECbdq04fbt22TPnh0XFxe+fPnC3r17E+xn4sSJTJo06ZftW7ZswSCFl4AEQRCEtCskJIR27drx9etXjI0THqWcpE9uSfXt2zc6duzIypUryZ49e6KPGzVqFG5ubrH/DgoKIl++fNSpU+e3D+Z39u3bh7a2Nt26d0ffODOT1u4kc7bEZ0rXoqPR9L9NtHk50NSUO03qEs+5uXLqKItHDGDIQk/K29RIUfOSJNG7ZmXyFC7KuJVbUp5XXcRrJmHi3ADw3PcRq6aMwd/Hm9wFzbGyd6Rd3ZrUrl0b7RRMY/jzSt6fJKm4Zc+eHU1NTQIDA+NsDwwMJGfOnL/s7+fnR0BAAA0b/n/Axs/pWbS0tHj06BGFC/86QkxXVxddXd1ftmtra6fopADoGmbiVcBTJnVvx5TNezEwypSi9tIVTc0M/cv4W/86N3vXLAdNTcpUtU3x+foU+Ib3gW+p3rhF2jz34jWTsAx6bsLDQtm5dD77VnugpaNDp2HjcG7vyqF1P0ZLpvR9PLHHJmlAiY6ODlZWVpw6dSp2W0xMDKdOnYpzmfKnEiVKcPfuXW7fvh37X6NGjXBwcOD27dvky5cvKd0rRefhY4mJjuaF72Nm9HEhMkL908IIaVdMTAxPH9zDxrkR2jo6KW4vdmaSmk4pbksQ5Hbn4jkG1rNj76qllKpcjdUXbuPc3lWWLEm+LOnm5kbnzp2pWLEilStXZsGCBQQHB+Pq+uMBdOrUiTx58jB9+nT09PQoU6ZMnOOzZMkC8Mt2dSlhVYXKtZy5dvoY96/9zcJh/Rk8bxmaGfAvLCHpzu3zIjI8HJt6jZXSnt89b7S0tSliUV4p7QmCHL5+/MDa6RM4f3APRpmzMNZzE+VknhAjycWtdevWvH//nvHjx/P27VvKlSvH0aNHyZEjBwDPnz9P9Yt4dh4xnhtnT6Cjp8/lYwfJPDU73cZNRaFQyB1NSOUOb1qDUZaslK6knNWy/e7dwSCTcar/nRGE+EiSxJnd21k7fQLhYaE4Nm9D78lzUsXrOVkDSvr160e/fv3i/dnZs2d/e+y6deuS06VS5cxXgEauvdi72oMyVWw4umUdWc1y0KLXQLmjCalYVFQUz30fUqtFOzS1lDMW68m9O+QuKO+9n4KQHK/8n7B8/DDuX79Cjrz5mbbiIPlS0ULO8pdXmTTvOYBMmbPy9kUAFtWqs3XBTE7s2Cx3LCEVO7FjI1EREVSvr5xLkp/fBRL06SMlyldSSnuCoA6REeHsWDqPwY0c8b17m/ZDRuNx8u9UVdggAxc3fSMjOg4dw4fXr6hcqy75i5ZgxYThXDl5RO5oQip1YtsmsmQ3pbiSitHPmUkqisEkQhpx//oVBjd0ZMeSuRQuU46V527SrHv8V/HklmGLG/xYKbZQydJsmTed6dsPYpIjF3MH9cLn2t9yRxNSmYjwMF76P8G2QTOlfZ/g7+ONppYWxctZKaU9QVCV71+/4DF2COM6NOXrpw8MXbiS6dv2p+rJ5jN0cdPQ0KDr2CmEBgezespYFhw8jYGREdN6duTZowdyxxNSkeM7NhIdFYlNvUZKa9PPxxtDMZhESMUkSeL8wT30c7LhzJ4dVK/fhLWXfahap57c0f4ow/9WlbSqgrVzQ/46sIuw4BDm7j0JwCTXVrx7+ULmdEJq8dfeXWTPlZsiFuWU1qav9y1yFiiktPYEQZkCXz5ncte2LBjaFx1dPWbuOMzguR5oKWkwlapl+OIG0GnYOABmD+hGtpy5mLbtACHB35no2oqvnz7KnE5IDQJfPceuYXOl3S7y5cN7vn78QPFyFZXSniAoS1RkJHtXezCgnh0+1/6mRe9BeJ67gXlpC7mjJYkobvxYXK9J9774et/i3tVLFChWgjErNvLhzSumdGtHaHCw3BEFmUVHRSn9kiRAJTGYREhFfL1vMaxZHTbOnkK+wsVYfvoqbQcOlztWsoji9o+m3fqROVt2Fg79MfLHomp1+s9YSMCj+8zq34XIiAiZEwpyypmvAAWKl1Jaez8Hk5S0qqy0NgUhuUK+f2P1lLGMbN2Ad69eMmDmYubsOZ6m17sUxe0fegYGdBo+nk/v3nJgnScAtg2a0mHIGO5evsDS0YNjJ30WMo7v374CUK1uQ6XOYOPn4y1mJhFShSsnj9C/bnWObllHJYfarL10F/vGzeWOlWLiN+tfbBs0pYhFObYtmhX7Sa1xl17U79yd8wf3sH6mO0lY/k5IBw6t//GHTtU69ZXa7hPvW+TMV0CpbQpCUnx8+5oZfVyZ1a8rEuC+aQ8jPdaho6cndzSlEMXtXzQ0NOg2biphISEsHfP/9eRcR07ExrkRB9d7sm+1h4wJBXW7dPQQAHkK/bo0U3J9/fSRz+/fUUzc3ybIIDo6msMbV9Pf2ZZb50/ToHN3Vv11i5IV0tdMOWljTKcaFS1bHrtGzbl4eB/t3UZhmisPAG7zl/PpfSAb50zF2CQ7js1ay5xUULUvHz/w+d1bpbf7c5mbSo51lN62IPxOwEMfPMYMwc/Hm7yFizHGcyNmedS/9Jg6iE9u8egwZDQamprM7tc1znb3DbvIU6gIHmOHcOPsSZnSCeqye/lClXzP6u9zF01NTUpXtlZ624IQn/DQEDbOmcLQZk689POlx4QZLDx0Nt0WNhDFLV7ZcuSiRa+B+N+/y+2L52K3a2hoMGfPcbJkN2XWgG48unVdxpSCql06dpBCJZW/7qCfzx30jcRgEkE9bp0/y4B69uxbsxyLqtVZffEOTm07yR1L5cRvVwIauvbExCwnS0bEXQZHR0+PBQfOoKunz+Tu7Xnx5LFMCQVVev/mFV8+vKda3QZKb9v3zi1y5Muv9HYF4d++fHjPPLfeTOnejvDQEMat2sKENdvQNzSSO5paiOKWAF09fTqPnMDnD+/Y7bk4zs+MMmdhzp7jxERHM8m1FR/evJIppaAqXh4LkGJiqFrbWantfvv8iU/v3orJkgWViYmJ4eTOzfRzsuHv44eo1aoDay7dxdLaTu5oaiWK229Y121IiQqV8Fq2gIiwsDg/M8uTjymb9vDt6xcmubbm25fPMqUUVOHa6WMUL1cRE7NcSm3358wkVg61ldquIAC89PNlXPumLBs3DONs2Zl/4DS93WdlyEvgGe8RJ4FCoaDrmMmEh4WxeOSvq3Sbl7Zg1NK1BL58ztQeHQgPDZEhpaBsbwL8Cfr0EduGTZXetv/9u2hoalKmio3S2xYyrojwMLYtms3gRo743/em0/DxeBy/RJ5CReSOJhtR3P7AvHRZHJu24srJI7x59vSXn5ezdaD35Dn43fNmzsAeREVGypBSUKYdHgsAqOak/O/b/O55Y2CUKc3MrC6kfveuXGJQAwe8li2gWDkrVp6/TeMuveSOJTtR3BKh3eBRaGlrM2dA93h/7tC0FW0GDuPW+TMsHzdMzGKSxt366zSlK1uTJbup0tv29b6FWV4xmERIuW+fP7Fk1GAmdG7B9y+fGb5kDVM378XIOLPc0VIFUdwSIaupGS37DCbg8QOunTkR7z7New7AqW0nzuzdwaZ509ScUFCWgIf3+fblE7YNmii97W9fPvPx7WuKWZZXettCxiFJEuf276Jf3eqc2++FbYNmrLl8j8pihYk4xLWRRGrQuTvHtm5g2Rg3Kl70jncS3e7jp/MpMJC9K5eSJZspDV16yJBUSAmvZQvQ0NCkSm3lrzT89ME9AKxqiMEkQvK8fR7A8gnDuXv5Atly5Wbi2h0UKqX8ezHTA/HJLZG0dXRxHTWJr58+smPJvAT3G7F0DUUtK7BuxkT+OrBbjQkFZfC+fB5LGzsyZcmq9Lb9fbzR0NSkbAYbki2kXFRkJLs9FzOwvj0Pb1ylVb8heJ65Lgrbb4jilgSVa9WlVKVq7F299LcLmE7bup+c+QuyeMRAbl84q76AQoo8vnOD4KCvVG+g/FGS8GMwib6hkRhMIiTJ49s3GNKkNpvnTadAsZIsP3Od1v2GyB0r1RPFLQkUCgVdx04mMjychcP7JbifhoYG8/efxtjEhJl9u+DrfUuNKYXk2rV8EZpa2ir77sLX+1a6nstPUK7gb0F4ThrFqLaN+Pj2FYPmLGXWrqNkyZZd7mhpgihuSVSweClqtWrPjbMneeHnm+B+Onp6zN9/Gi0dbSZ3a8cr/ydqTCkkh8+1y1jZ18TAKJPS2w4O+sr71y8pallB6W0L6YskSVw+doj+datzYvtGKtesy9rLPtiq6IpCeiWKWzK0HTgCHV095gyM/9aAn4xNsjHL6yiREeFMcm3Np0DlL58iKMfdvy8Q+v071VUwShLA//4/g0nsa6qkfSF9+PDmFdN7d2bOwO4oFBpM3bKPEUtWo62jI3e0NCfDFbfIsPAUt5HZJBut+w/l5ZPHXDp28Lf75ipQiEnrd/L100cmdWlDcNDXFPcvKN+elUvR1tHFyr6WStr39/FGQ0MTSxt7lbQvpG3R0dEc3LCK/nVtuXPxHI269GblXzfTzYK2Id+/8ezRA7X2mWGKm4WFBQCrpo4hOjo6xe05t3clR74CeE4Y8cc1v4pZWjF0oSdvnvkzrWcnwsNCU9y/oFyPbl2jcq266BkYqKR9Px9v9A0NxV/gwi/8799lRAtn1k4bT878BVly/BKdh49LF/NBfn4XyKa50+jlUIlrp46qte+0f/YSydzcHIC7l86zYdbkFLenraNDl9HufPvymS3zp/9x/0qOdeg+bhqP7txgvlsfoqOiUpxBUI7rZ04QFhKCTb1GKuvD1/smpnnyqqx9Ie0JCwlh/cxJDG/hzOsAP3q5z2b+gdOY5sojd7QUe/3Uj2XjhtG7VhVObFtP7549uHv3rlozZJji9tOMGTM4uN6TEzs2p7gtqxq1KGtty8ENqwj5HvTH/Wu37kDL3oO4duY4npNGimm6Uol9a5ahq29AeVsHlbQf8v0b716+oIiFmJlE+OHGuVMMcLblwPqVWFrbsebiXWq3ai93rBTz9b7F7P7dGFDPDu+/TuI+aRIvnj9n9uzZ5Mql3BU2/iTD3XDTo0cPfHx88HQfRc78BbGomvzZ2RUKBV1GT2ZwI0fmu/VhjOemPx7Tuv9QPga+5eTOLWQxNaPtgOHJ7l9IuZiYGJ7cvYN13Qbo6OqppI+n/wwmqSAGk2R4n9+/Y/XUsVw+epBMWU2YsGYbFlWryx0rRSRJ4tb5M+xb5cG9q5coUqQoK1asoGPHjujpqeZ3KjEyXHEDWLRoEb6+T5g7sDvTth0gd6HCyW4rX5Fi1G3bmWPbNvDs8UMKFCvxx2P6TJnD53dv8fJYQJZspji3d012/0LK/H3sIBFhodjUa6yyPvx8vFFoaFC+eg2V9SGkbjExMZzcsZn1s9yJjAjHqW1nuo2bmqa/V4uKjOTikf3sX+1BwKMHVKpUmV27dtG4cWM0NTXljpfxLksCaGlpsXPnDnLnysmMPi58//olRe217jcEXX0D5gzoluhjRi3fQKFSFqyaMpaLR/anqH8h+Q6s88TAKBNlq9mqrA9/nx8zk+jI+FesIJ/nvo8Y064xKyaOIKuZGQsPnqXHhOlptrCFhYRwaMMq+jvZsGh4f0oUKsiZM2e4cuVvmjVrlioKG2TQ4gaQJUsWDh44QMjXz8wd1DNF67BlympCu4HDeR3gz/mDexJ1jIaGBjN2HMIsd14WDO2L9+Xzye5fSJ6YmBiePvDB2rkRWtraKuvn8Z2b6WKQgJA0ERFhbF04iyFNahHw0AfXUZNYcvQiuQqayx0tWb5++si2RbPp5ViJ9TMnUdvBnjt37nDkyGFq1KgR72TycsqwxQ2gSJEi7Nm9mwfX/2b11HEpGuBRp00nchc0Z6X76D/eGvCTlpYW8/afwihzFmb0ccHfxzvZ/QtJd3bvDiIjwqleX3WXJEO/fyfw5XMKW5RTWR9C6jSyZX12LV9IifKVWHX+Ng06/37Sh9Tq7YtnrHQfTW/HyhxctwLXTh3x8/Nj06ZNlC1bVu54CcrQxQ3A3t6e5cuXc3zbBg5vXJ3sdrS0tekyZgrBQV9ZP8s90cfpGxoxb98pNDQ0ce/alrfPA5KdQUiaw5vWkilLVkpVqqayPp4+9AFJooKdakZiCqlL0OePrJj4Y5BYcNBXRi5bx+RNuzHMZCxzsqTzv3+X+W696e9kw7XjBxk9aiQvnj9n4cKFFChQQO54f5ThixtAly5dGDp0KOtmTOTmX6eT3U552xpUsHPk2JZ1fPvyOdHHZTU1Y/qOQ4SHhjLRpSVfPrxPdgYhcaKionjh+4jq9Zuo9DsC/38Gk6hq5hMhdZAkibN7d9Kvjg0XjxwAYOnJv6mYxtbukyQJ78vnce/ahmHNnHjhc4dFixbx/Nkzxo8fT7Zs2eSOmGiiuP1jxowZ1G/QgPluvXju+yjZ7biOmkR0VDTz3Hol6bh8hYsyfvVWPr9/h3vXNoR8/5bsDMKfHd+2kajICJVekoR/ZiYxMBSDSdKx1wH+THRpxeKRAzEwNmbK5n0AaGmmncHo0dHRXDyyn5EtnZnk2hq+B7F161aePPGlb9++GKho5h5VEsXtH5qammzZvJnChcyZ2aczXz99TFY7uQsVpn6nbtz7+xL+Pkm7I79kxSoMmuPBiyePmd7bhciIlM+DKcTvxPYNZDXNQbFyFVXazxPvW2TPlVulfQjyiIyIYNfyRQxq4MCjW9dpO3A4y09dJX+RYnJHS7TwsFCObl3PgLrVmTe4F/lzmHL8+HFu3bpJmzZt0vTag6K4/YuRkREHDx4gJiKc2f26JLu4tOwzCH0jI+YM6pHkY6s51cd1lDsPblxhwdC+SpkHU4grIiyM1wH+2DZootLh2GEhIbx59hTzMpYq60OQx8Ob1xjSpBZbFs6kUMnSrDh7jRa9B8kdK9G+ffmM1/KF9KlZhdWTx2BbrQrXrl3j1MmT1K5dO9WNfEwOUdz+I3/+/Ozbuxd/H2+WjxuerBGUhsaZ6eA2msAXzzi9e1uSj6/XwZUmXXvz9/HDrEnhKE7hV4c2riYqMhKbek1U2k/Aw3tIkkQFFU3rJahfcNBXVkwYwZh2jfkU+Ba3uR7M3HmYzCZpYwHRD29esXb6RHo7Vmb3sgW0admCR48esWP7dipWVO1VDHVLu585Vahq1aqsXbuWdu3akadwEZr16J/kNmq2bMfhTWtYO30iNZq0SvInhA5DxvDpXSBHt6wjq6lZmvqrMLU7vXsb2XPnoXAZ1Q5j9rv3z2CSNDaoQPjVjwVED7Jy0ii+f/1KVaf6DJq9NM2s8vD88UP2rV7G+UN7MDIywm3wIPr370+OHDnkjqYyorgloG3btjx48IDJkyeTp1ARqtR2TtLxmpqadB07hYkuLVk9ZQzdx/955YD/GjBzEZ/fBbJ14SyMTbJTp3WHJLchxBUa/J3AF89o3LWPyi+9+PvcRd/AUGXL6Ajq8e7VS1ZOGsnNv06T1SwH07ftp0jZ1D8JtiRJPLhxlb2rlnLj7Eny5M3L7Fmz6NatG5kyKX+1+dRGXJb8jYkTJ9KiZUsWDe+P//2kL9dgUdWGyjXrcnLnVr58/JCsDONWb6VAsZJ4ThzBlRNHktWG8H/71ywnOiqK6iqcS/In37u3MMmp3pnQBeWJjopi/9oVDHC2xfvyeZp278uqv26l+sIWExPDlZNHGNuuMeM6NCX0/RvWr1+Pv58fgwcPzhCFDURx+y0NDQ3Wr1tH6dKlmNnHhU+Bb5PcRueRE5CkGOYOTPrgkp8ZZnodwSRnLuYO7oXPtb+T1Y7ww7l9XuQqaE7+RExwnRLhoSG8fupH4dKpdwYHIWF+97wZ3qIu62dOInchczxO/E2HIWPkjvVbkRHhnPTawuAGNZjVryvZjfQ5ePAgd7296dSpEzpp5BKqsoji9gcGBgYc2L8fHU0NZvZ1JTw0JEnH58xXgIauPXlw8yqPbt9IVgZtHR0WHDiNgZER03p2JODR/WS1k9F9//qF929eYdewmcovSQY8vI8kSZSrbq/SfgTlCg0OZu30CYxo6cybZwH0mTqXeftOkS0VfwIP/hbE3lVL6VOrKsvGDsWqbBkuXbrE+b/+on79+ml2guaUypiPOoly5crFwQMHeOXvy5JRgxM9d+RPLXoOxChzFua79U52BgMjY+buPQnAJNfWvHv5ItltZVR7PJcQEx2NjbPqVtz+yc/HG4VCQSVHJ5X3JSjH9TMnGOBsy6GNqylv68Cai97UbN5W7lgJ+vwukI1zp9LbsRLbFs6icf16PHjwgL179lCtmuqmlEsrRHFLpPLly7N50yYuHT3A9iVzknSsvpERHYeO4f3rlxzbtiHZGbLlzMW0bQcIDf7ORNdWyb7RPKM6f3gv+YuVII95EZX39fT+XfQMDNE3NFJ5X0LKfAp8y+wB3ZjeuzPRUZFMWu/FGM9NqXYg0Cv/JywbN5TetapwctsG+vTqRUBAAGvWrKFECdVebk9LRHFLgqZNmzJ9+nS8PBZw/sDuJB3r0LQ1BUuUYuPsyURFRSU7Q4FiJRizYiMf37xmcre2hAYHJ7utjOTz+3d8CnyLXcNmaunvsfctTHLkVEtfQvLExMRwdOt6+tWtzrXTJ6jb3pVVF+5QulJVuaPF6/Gdm8zq35WB9e25e/40k93defniBbNmzSJ3bjELzn+J4pZEI0aMoFOnTniMHcLjJHyHpqGhQdexUwkNDsZz4ogUZbCoWp1+Mxbw7NEDZvXvQmRERIraywh2r1iEFBODtRouSYaHhfLK/wnmpcRgktTq+eOHjG7TkJWTRpEtZy4WHjpL91S4MrYkSdw4d4rxHZsxqnUDPgX44enpybOAAEaMGEHmzJnljphqpa5nMg1QKBR4enpSqVIlZvXrwvvXLxN9bKmKVahWtwHn9nnx+V1ginLYNmhKhyFjuHv5AktGDUry94AZzeVjhyhcxpIcefOrvK9njx4gxcSIwSSpUHhYKJvnTWdIk9o8e/yArmOnsPjIeXIVKCR3tDiiIiM5u8+LIY1rMq1nRwwVErt37+bBg/t069YNXV1duSOmeqK4JYOuri57du8mcyYjZvRxIfT790Qf22nYeABmD0j5woWNu/SiQefuXDi0l/UzJ4lpuhLw7vVLvnx4p7ZLkv7/DCapXEsMJklN7lz6i4H17dmzcgmlKlVh9YXb1OvQRe5YcYQGB3Nw/Ur61bFm8YgBlCpszrlz5/j778s0bdpUpcszpTeiuCWTqakpBw8c4OPrlywclvgJjs3y5KVJt7489r6plHvWXEZOxKZeIw6uX8neVUtT3F565OWxAAmoVreBWvrz/2cwiYFR2lugMj36+ukjC4b1w71LG0K/fWf0io1MWu+Vqp6frx8/sHXRLHo7VmLj7MnUreWIt7c3hw8fws7OLl1MZKxuorilQOnSpdmxfTs3zp1i09ypiT6uSbe+GGc1YeHQvkrJ4TZvOaUqVmHT3Gmc3pX0iZrTu2unj1GifEWy5VDPvUq+d26R1Sz9ztmXVkiSxOld2+jnZM2lw/txbNaGtX/fo4Kdo9zRYr198YyV7qPo5ViZQ+s86eLSGT8/PzZs2ICFhYXc8dI0UdxSqG7dusyfP5/9a5Zz0mtLoo7RNzSk0/DxfAx8w8ENq5SSY9KGXeQxL4LHuKFcP3NCKW2mB6+ePuHb50/YNmiqlv4iwsN46edLoZJl1NKfEL/XT/0Y37E5S8e4YWSchbn7TtB32rxUM2DE38ebeW696O9kw7Xjhxg7ZjQvnj9nwYIF5M+v+u+FM4LU8Uyncf3796dHjx54ThyJz9XLiTrGrmEzCpcuy9YFM5Qy2lFDQ4O5e0+SNbsZswd25+HNayluMz3Y6bEAgGpO6rkk+fzxQ2JiosVgEplERkSw02M+gxo64ut9i/Zuo1h26gr5ihSXOxqSJHHn0l+4d2nDsOZ1efXgLosXL+b5s2eMGzeObNmyyR0xXRHFTQkUCgVLlizB3t6e2QO68ebZ0z8eo6GhQbdxUwkLCWHZuKFKyaGto8P8g2fQ09NnSo8OPPd9pJR207Lbf52hTBUbMmdTz3pb/j53QaGgcq2krSIhpNyDG1dwa+TI9sVzKFzaAs+z15O1XJWyRUdFcfHwPka0qIt7lzYoQr6xbds2fB8/pk+fPhik0pvF0zpR3JREW1sbr507yWlqyow+LgQHff3jMcXKWWHboCkXDu3jw5vXSslhZJyZ2XuOExMdjXuX1nx480op7aZFT+/f49vXz1Rv0ERtffr5eKOnb4CRsbj/SF2+f/3CsnFDGdu+KV8+vGfIAk+mbz+IsYm8n4TCw0M5umUdA5xtmefWm4I5c3D8+HFu3rxB69at0dISK46pUrKK29KlSylYsCB6enpUqVKFq1evJrjvypUrsbW1JWvWrGTNmpVatWr9dv+0LGvWrBw6dJDvnz4wd3BPohMxE0nHoWPQ0NBg1oCuSsthlicfUzbt4fvXL0xybc23z5+U1nZa4rV8IRqamlRR46coX+9bZDU1U1t/GZkkSVw4tJd+datzevd2bJwbsebyPao51Zc117evnwFwa+jI6iljsbOuyvXr1zl58gS1a9cWIx/VJMnFbfv27bi5uTFhwgRu3ryJpaUlTk5OvHv3Lt79z549S9u2bTlz5gyXL18mX7581KlTh1ev0ucniqJFi7J71y58rlxizbRxf9w/W87cNOvZH/973ty+eE5pOcxLWzBy6VoCXz5nSo8OhIUkbTWD9ODu5fOUq16DTFmyqqW/yIhwXjx5JAaTqEHgy+dM6daO+UP6oK2jy8wdh3GbvxxtbW3ZMr1//ZK10yfg1vDHaMwWTZvw+PFjtm/bhpWVlWy5MqokF7d58+bRvXt3XF1dKVWqFMuXL8fAwIA1a9bEu//mzZvp06cP5cqVo0SJEqxatYqYmBhOnTqV4vCplYODAx4eHhzdsp7Dm+I/L//WuEsvspiasXjkQKXmKGfrQO/Jc/D38WbuoB5ERUYqtf3U7NGt6wR/C6J6/SZq6/P540fEREdjaWOntj4zmuioKPau9mBgPTvuXb1M814DWXnuBual5Rs2/+zRAxaNGEDfOtZc2O9Fv759gB/vlYULF5YtV0aXpIu+ERER3Lhxg1GjRsVu09DQoFatWly+nLhRgiEhIURGRmJiYpLgPuHh4YSHh8f+OygoCIDIyEgik/kG/fO45B6fVC4uLjx+/Jhl86eTp6A5ltVsE9xXV0eXriMnsnSMGwfWLKNh5+QtbBofh0bNCfr4Hi+P+ax2H0mPCTN/vSzy8wb0RN6InhYcWLOMTMbGVKpRM2WPKwnn5tlDH/QNDKhS0yldnct4yfCa8b/vzUr3Mbx48ojCpSwYumAFWU1zyHKuJUni4a3rHNrgye0L58iTNy9z58yhc+fO6OjocOLECbW916QVynoPTuzxCikJcza9fv2aPHnycOnSpTjrBQ0fPpxz585x5cqVP7bRp08fjh07ho+PD3p6evHuM3HiRCZNmvTL9i1btoiRRYIgCBlYSEgI7dq14+vXrxgbJzzLjFqH68yYMYNt27Zx9uzZBAsbwKhRo3Bzc4v9d1BQUOx3db97ML8TGRnJiRM/vtBV53X5b9++Ubt2HT59+8aEdTsxzpLwJ1b/+3cZ36k5VWvXo9/0BUrPMn9oX26cPUG7wSOp1/5fc+pFR6Ppf5to83KQDuauu3flEjP6utB/xsKUDyZJwrkZ074JocHfmffPorLpmppeMzfOnWDt9IkEffqIZXV7+k9fiI5uwu8dqhIZGc6FQ/s4snE1r589xdrGhsGDBsU7QESu95rUTlnn5eeVvD9JUnHLnj07mpqaBAbGndE+MDCQnDl/v3bVnDlzmDFjBidPnqRs2d8vBaKrqxvvrNfa2topfrEoo42kMDExYdcuLypVrsycQT0Zt3ob2jo68e5rblGOqk4N+evgblr2H0qOfAWUmmXw/OWMat2A1dMmYJQ1268TCWtqpovitmvVUqJjJMrZOSrv8fzh3ERGROB7786PlbfTwTlMNBW9Zj4GvmGV+xiunjpK5mymjFqxiZIVqyi9nz8J/hbE8W0bOLxhFZ8/vKdxkyZsWruaqlX/vOabut9r0oqUnpfEHpukASU6OjpYWVnFGQzyc3DI75Y1nzVrFpMnT+bo0aNUrFgxKV2mCwULFmTf3r343rmJ58QRv529v73bKDS1tJg1oJtKskzdup9cBQqxeMRAbp0/q5I+5Pb49nUq13JCV199l7Bf+j0mOiqKstYJf7cq/Fl0dDSHN62hf93q3Dh3ivqdurHq/C21F7ZPgW/ZMHsyvRwqsmPxHJo2asiDBw/Ys3t3ogqbIL8kj5Z0c3Nj5cqVrF+/ngcPHtC7d2+Cg4NxdXUFoFOnTnEGnMycOZNx48axZs0aChYsyNu3b3n79i3fk7BMTHpgbW3NmjVrOL17O/vWLEtwv6xmOWjZZzDPHt7nxjnlX97S0NBg3r5TGJuYMKtfF3y9bym9DzldO32csJAQtY6ShB83bwNUrVNPrf2mJwGP7v+4sjBlLKa587Lk2AW6jHZX63yQL/198Rg7hD61q3J652b69enD06dPWbVqFcWLyz+Fl5B4Sf7OrXXr1rx//57x48fz9u1bypUrx9GjR8mR48cs6M+fP4/zYly2bBkRERG0aNEiTjsTJkxg4sSJKUufxrRv354HDx4wbdpU8hQq/OMSVjwadO7Osa0bWDrajTUXvZWeQ0dPj/n7T9PXyYbJXdsyY9sB8im9F3nsX7MMPQNDylWvodZ+/X3uoqdvQGYT9UzzlZ6Eh4aww2M++1YvQ0dHl+7jp1G3nYtaMzy6dZ19qz24euoYOXLmZMrkyfTs2VOsdJ2GJWtASb9+/ejXr1+8Pzt79mycfwcEBCSni3TL3d2dBw8fsnBoPyZv3hPvDb86unq4jprE7AHd2LF0Hq36usXTUsoYm2RjltcRhjSuxfTenfFYtEDpfahbTEwMT+7dwca5Edo66l2p2Nf7ltrmr0xPbl84y7Jxw/gY+IYyVWwYsWQ1+oZGauk7JiaGW3+dZu+qpdy/foVixYqzcuVKOnToIFa6TgfE3JJqpqGhwYb16ylRojgz+7jy+X38M7tUqe1MqYpV2bNyicpmF8lVoBDuG7z49uXHdEHB3/48H2ZqdunIfiLCwrCp10St/UZFRvLs0QMKlCit1n7Tsq8fPzB/SB8md2tHWEgwYz03MXHtdrUUtqjISM7u3cmQxjWZ1qsTmTQV7NmzhwcP7tO1a1dR2NIJUdxkYGhoyIH9+9FSSMzq60p4WOgv+ygUCrqOnUxkeDgLh8f/KVkZipQtz8BZiwCYM7BHvFnSioMbVmGQyRiLqjZq7felvy/RUZGUta6u1n7TIkmSOOm1hb5ONlw+dpCaLdqx9vI9tVxGDg0O5sA6T/rVsWbxyIGUKVqEc+fOcfnyJZo0aZJq1noTlEM8mzLJkycPB/bv54XvQzxGu8U7grJgidLUatmOG2dO8OrpE5VlKW/7Yy68J/fuMG9wr0RN+JzaxMTEEPDAh+r1GqOl5uHX/vf+GUxSW94Je1O7l/6+jO3QlGVjh5I5qwnzD5ymz5Q5Ki8qXz9+YMuCmfR2rMSmOVNwrl0Tb29vDh06iJ2dnZjIOJ0SxU1GVlZWbNiwgQuH97Fz6bx492k7cARaOrrMHtBd5XmadO3L9bMnWfGH2xVSo9O7txMZEY5NvcZq79vPxxtdfX2xGkACIiPC2b54Dm6NauJ/7w4dh41l6YnL5ClURKX9vn0egOekUfRyrMyRjavo1sUVPz8/1q9fj4WFfHNRCuohFhSSWYsWLZgyZQpjx44lj3mRX96cM2fLTpv+Q1k/y52/jx9W6VDz5j378+7NK07u3ExW0xy0HThcZX0p29HNazHOaiLLjb5P7t4WoyQT4HP1Mh5jhxD44hnFylVk1LJ1Kl+lwe+eN3tXL+XvY4cwyZaNcWPH0KdPn9/OZyukP6K4pQKjR4/m4cOHLBk1GLO8+Slatnycnzt36MLRLetYPn44lWvVVellnN6TZ/Pp3Vu8li0gc7bs1OvQ5c8HySwqKooXTx5Tp01HNNU8O0h0VBTPHt2nXHUHtfab2n378pmNsydzatc2DDIZM2zxaqrUqquy/iRJwvvSX+xd5YH35fMUMjdnyZIluLi4oK+vr7J+hdRLXJZMBRQKBStXrsSqQgVm9nH5ZfVsbR0dXEe78+3LJ7YunKnyPKOWrce8dFlWTx3HxSP7Vd5fSh3bup6oyAhsnBupve9X/k+IjIigTFUxmAR+FJnzB3bTr251zuzdiW39pqy9fE9lhS06KooLh/YyvHld3Lu2RTM8mO3bt+P7+DG9e/cWhS0DE8UtldDT02Pv3j1kMjRgRm8XQoOD4/y8okNtLKpV58A6T0K+J27i0OTS0NBg+vaD5MiTjwVD+3Ln0l8q7S+lTmzfhIlZToqVU/+CkD9nJqlWRwwmefviGe5d27BgWD/09PSZtfMIg+YuRUtL+ReIwkNDOLJ5LQOcqzN/SB/Mc+fk5MmT3Lh+nVatWqn9E7yQ+ojiloqYmZlx8MAB3r18xqLh/YiJiYn9mUKhoMvoyURFRjJ/SF+VZ9HS0mLe/tMYZc7CjD4u+Psof6YUZYgIC+N1gD+2DZvKMpTb38cbXT19sv1h4vD0LCoykj0rlzCwvj0Prl+hVV83Vpy9TqFSyl+R/NvnT+xYOo/eNauwZuo4athYc+PGDU6cOE7NmjXFyEchlihuqYyFhQXbt23j+pkTbJ4/Pc7P8hctjlObTty+cJbnvg9VnkXPwIB5+06hqamFe9e2vHn2VOV9JtXBDSuJjorExln9oyQBfO/extgkmyx9pwZP7t1maNM6bJo7jfxFS7Ds1FVa9x+q9H7evXrJ6qnj6OVYmX0rl9ChbRt8fX3ZunUrFSpUUHp/QtonilsqVL9+febMmcPelUs5vXt7nJ+16T8UXX0D5qjh1gCArKZmzPQ6THhYKJNcWyU4o4pcTu/ehlmefJiXVv/Q7ujoaAIe+FCgWEm19y23kOBvAEx0bc37Ny8ZOGsxs3cdVfrtEAGP7rNweH/61anGpYO7GTZ0CM+fP2fJkiWYm5srtS8hfRHFLZUaNGgQXbt2ZcWE4dy//v8VzjNlNaHtgGG8eurH+UN71ZIlT6EijF+znc/v3+HetS3B31T7nV9ihQZ/592LF9g2bCbL5ajXT/2IjAinjJpnRJHblRNHGNq0DgBWdo6svXgXu0bNlda+JEn4XL3M1B4dGNK4Fk9vX2Pu3Lm8eP4cd3d3TE1NldaXkH6J4pZKKRQKPDw8sLGxYXb/rrx98Sz2Z05tO5O7oDmrJo2K872cKpWsUInBc5fxyu8xM3q7EBEeppZ+f2fv6mVER0dRXYYbt+Ffy9w4ZYzBJB/evGJ6Hxdm9e8a+8fE4LnL0NFTzsrY0dHR/H38MKNbN2B8p+ZEfHrPxo0b8XvyhIEDB2JkpJ4JlYX0QRS3VExHR4fdu3Zhms2EGb06xX5i0tLWpsuYyXwP+srG2ZPVlqdqnXq4jHLnwc2rLBzWj+joaLX1HZ+/9u8iT6HC5C9WQpb+/X280dHTwzRXHln6V5fo6GgObVhFf2dbbp8/Q0OXniw+ckFp7UeEh3Fix2YGN6jB7AHdyJnVmMOHD+PtfYcOHTqI1ayFZBHFLZUzMTHh0MGDBH18z/x/zftY3taB8rYOHNm8lu9B6pvNv14HV5p268vfxw+zespY2abp+vblMx/evMK2YTNZ+gfwu3sH46zpe9aLpw/uMbJlPdZMG0+OvAVYcvwSLiMnKGVkanDQV3Z7LqZvraqsmDCcyuUt+fvvvzl39izOzs5i5KOQIqK4pQHFixfHa+dOvC+f53/t3XlcjdkfB/BP222RCtFCQ0VjnTFjaUqmYaKsMT/LjIbEtCBJUypbWUpjKmvKUmI0IktISqIZS7YUaSOthkq2Umm75/eH0UzcjFvde3V9369Xf3juOc/zvd+5c7+dp/OcE+rj2XDcyn0V6uvq4e9oJ9R4LJzcYWw+BbH79+BQ4EahXvu1I9u3gFtfL5IHt4FXCzXnZKTik16iGTUK2svKSuxZvxou/zPDX7nZsFu1HhujzrXKKPVx8UPsWb8adiOHIGKrH74zn4iMjAwcOXwY+vrCXz6NiCdafquNMDExwdatWzFv3jx01e0Fsx8s0VWnJ8bOnIPo30KQk54Knb7CmzHo8MtmPH1UjPDNv0K5oypGfz9TaNcGgIunjqPHp32hqa0r1Ou+9iDvHmpevhTLySQ3/jyLoJVL8KSkCJ8ZDMeSLbsgp9Cuxee9f+8ujgVvw58njkBeXh4O9vZwcHCAhoZGK0RNSGNU3NoQOzs7ZGRkIGDtcmh80gOfDzPG1PmLce7IAfg52iLg9CWhxrNi1344Tx6FHavcoNSxk0AXdf63JyXFeFpShLE/WgnlerzkpKUCAL4aJZz3LAxPH5UgxHsFLp06gfYdOmJlcDg+M2j5smKZN67hWPA2XI2PhbqGBry9vGBrawslJaVWiJoQ3ui2ZBvj5+cHE5NR8HO0xf2cu1BUVsEMJ3cUFeQhIfKgUGORlJTE+sOx6KiuAX+neUi7miiU6x4O2gQulwtDM9HckgRerTzPkZODmlZ3kcXQWrhcLk4f2IeFZka4EncKo7+fhZCLt1pU2LhcLq6fi8MKi0lYNsMcz//KR3BwMPJyc+Hi4kKFjQgcFbc2RlpaGgcOhOMTrW7wsbNE+dMnGDXVAt10eyHYa6XQHg34dzwbT5yFgqIivGxnIi8zTeDXvBwXjZ4DBqJLNy2BX6sp927fRHuVtj+ZpDD7DpZbTMJ2jyVQUe2MTVEJsPX0afaEkdqaGpw7ehA/m3+LdfMsoSQjhcjISKSnpWHOnDmQlZVt5XdACG9U3NogZWVlnIyKQk3lC/gusgaXy8Xc5WtRWV6GEK8VQo9HQVEJfpFnICEhgVVW36P4foHArlXyVyGelz4S6SxJLpeLnPRb0OqpJ7IYWqqm+iX2b1oPJ/NvkZueCktXD2yNvQiNHs1b9aPqxQsc370d9qMNsdXdEQP0euH8+fO4dOkizM3NRbLuJ/m40SeujdLW1kbk0aO4k5KEnavdMeArIwweORpxB8NQ9uSx0OPppK4B7/ATqKp8Ac/ZU/H8calArhOxbSMYAEPT8QI5//soys9FdVUV+g01EFkMLZF6+SIcx32Dw0Gb8OkXg7HzfAomWtk261zPH5cibIMP7EYOQZifF8aZjkJqaiqiok7AyMiIpvMTkaHi1oYZGRlh586diD+0Hyd2b8dsVw9wufXwc2zeF1VLddfrjeU7w/C4qAhrrGeg6sWLVr/G9XOn0efLoeioJrpV+NvqNjflT59gq5sjPGdPxYuyZ3AN2I21+45CUUmZ73MVFeYBABZPHIHYsBDY/DQXOTk5CA0NRf/+rb8bACH8ouLWxs2aNQtubm7Y++sa3L93FxNm2yD9+mXcvXVDJPH0H2oIh/WbkZ+VgV8WzkFtTU2rnbvw3l2UPX2C4RMmt9o5myMnPRUcWdlm38ITNsYYEo4dwgLTYfjzxGF8PXEKQi7dxpCRo/k+V3bqTfgusoHLd6YAANclS1BYUAA/Pz9oaYnub6CEvImKmxjw8vLCRHNzbHJZgCEjR6OdkjL8F88TWTxGY80x03k5bl++iC1ui1ptksvhwI2QkJDAVyIeMWWn3oSicgeRxvC+HubnYpXVNGxxdYCCYnusPxyLRes387WBKGMMyecT4Dl7GlynjkFxdgb8/f0BAM7OzujQoW3kgnxcqLiJAUlJSez77Tfo9eqFzS4LMWG2LUr+KsTp8N9EFtNEK1uMt7TBxehjCPXxbJVlupLPn8OAr4ZBWYT7pzHGkJN2C1q9PhVZDO+jtqYGh4M2w3H8N8i8cQ3TF7og6OxV9Ojd973PUV9Xh/NRR7HkO1OstZ4BmdoqHDx4EHeysjBnzhwBRk9Iy9FD3GJCUVERUSdOYPCQIbh2Nhaa2rrY++sajJzyA1+/pbem2W4eePKoGCf37oKKamd8Z7Ow2efKTU/Fi+fPMHycaG9JFhXk4WVlBfoO/kqkcbxL5o1rCFzujPu52ejZ/3O4B+2FSifV9+5fXVWJ+MPhiArdjuL7hRg1ajR2bt2EESNGNEwQEfYjJ4Twi4qbGOnWrRtOHD+Or7/+GoodOqKq4gV2rnLDvDW+IovJyW8bnhYXIcx/HVQ6dcbI/33frPNEBG6CpJQUhpqYtXKE/Ml5PZnE7MObTFJRXoYwP2/EHvgN8grtsNhvG1/bAZU/fYJTYbtfLcb9/BmmT58OFxcXfPHFFwKMmhDBoNuSYmbIkCHYs2cPSh8+AAAkREaIfPfsVXsPoZtuL2xb4YxrZ0836xyply/gi+EjoKis0rrB8SknPRUyHFl01e4p0jj+jTGGxJgoLDQdhriDYdA3GYPdibffu7CV3C9E8NrlsBs5FMeDt2GWxQxkZ2fj999/p8JG2iwqbmJo2rRpWLVqFQCgrrYWvzpYizQeSUlJ+B6NQwfVLvBdZI3MG9f46p9x4xoqy8swfNwkwQTIh+zUFCiqqIg6jAaPHtyHt90s+DraQFJKGl77I7Fkyy7IcDj/2TcvMw0bnRfA3tQQidGRcF3igvz8fGzZsgXa2tpCiJ4QwaHiJqZWrFiB73/4AQBw52YS0q9fFmk8MhwONkSdg5y8AtbaWKDgbtZ79z2yfTOkZWQweAT/U9dbE2MM927fQjfdXiKNA3g12eNE6A44jPkaty79iUk/LcCu88nQ+3zQO/sxxpB6+SLWWlvg50mjkHcrCf7+/igsKICnpyc6d+4spHdAiGBRcRNTEhISCAkOxqDBg8G4XGx0thd1SFBUUoZvZBwYl4tVVtPw6MH99+qXcf0KBo8YDXlFRQFH+G7F9wtQVfECfQeLdmWSnLRbWDLFDKE+ntDoro1tcZcx03nZO/vU19cjMfYk3KeNg+fsqah79hj79u3DvexsODg4oF27lm9pQ8iHhIqbGJOXl0fUiRPo1KkTHhc9wMm9u0QdEjprdsPafZGoKHuOVVbTUf70yTvbp1z8A1UVL/iaGCEoua+3uRHS1j5vqqqowO51nlgyZQwe5udh3lo/+B+PRyf1pvdDq6l+idMH9sFxnDF8F1lDs5MKTp06hZs3U2BhYQEZGRkhvgNChIeKm5hTV1fHmTNnICUlhbANPsjLSENN9UuRxqTdtz/cAveg5K9CrLG2wMvKyibbRu4KAEdODl8ajxRihLzdS7sFGQ4Hn4jgGbekhDNwGDMcJ3/bhS+Gj0DIxVswmfJDk+0ryp7jyPYtmP+tPnZ4uuKrQV/gypUrSDh3DmZmZrTmIxF79CjAR2DgwIFYt24dXF1d8fPkUZCQkIBaNy1o9NBFV52e+ES3F0Z/poenj4qhoqYhlC++gcOMMX+tHwKWLobvImu4bQuFNI9RxJ2UG9A3GQNZeQWBx/Rf7t2+iXZCnq35tKQYwV4rkBgbBaUOHeEZehD9hxo22f5x8UNEhe5A3MF9qK+thaWlJZydnaGn13Z3MCCkOai4fSRcXFwwe/ZsZGVlITMzE1lZWcjKykLGpT+QcHg/Ru/bh4VjhkNCSgpdtXUbCp+mti40tXWh0V0bsnLyrRrTN5Om4klJEX7f4INty3+G/bqNjbZGuXImBtVVlRj2AdySZIwhOzUFOv0GCOV6XC4XcQf3Ye/6NaitqYbZDEvMXe7V5NYxhdl3cCx4G85HHYWCggIcHRzg4OAAdXXRLTBNiChRcfuIdO7cGZ07d4aRUeMdlisqKnDmzBns37+/ofhlZmYh9tIfePL41fY5EhISUOuqBY0eOtDQ1kVX7X+KX8cu6s0e7X1nsxBPiotwKmw3VFQ7Y5bLP/vRHd8dBPl2ihhoZNz8N91KSh/+hcoX5UJZmaTgTiYCVzjjzs0b0NTWxdKgvdDozntqfuaNq4jcGYBr5+KgoamJdd7esLGxoZ2uyUePihsB5+9nosaOHQtz88ajpNLS0oZR3uuf9CsXcHr/HtTV1QEA5Nu1g2YP3YZR3uvCp9Fd+71uJ/60wgtPSopxLDgQKp06Y+Icu1cbgqbdgtFYc8hwRL97c15mOgBAf5TgJpNUv6zCocBNiNwZAGmODOYsW4NxM+e+1Y7L5SIpIQ7Hdm1Dxo1r+LR3b4SEhMDCwqLhvyUhHzsqbuSdVFVVoaqqimHDhjU6Xltbi9zc3Ea3OTMzsxB/5QJKHz1qaNdFsxs0tHXQVbtno+LXSV2z0WhvyZZdcP9+AvasXw1l1c6QkABqXr78IG5JAkBu5m1Iy3D4WniYH7cSzyNwuTMePbiPvkO+gtu23VBQbDz6qq2pwfmoozgREoiC7DswMDDEsWPHMH78eNrpmpA3UHEjzSIjIwM9PT3o6elhwoQJjV578uRJo5FeZmYmMq4nIu7Ab6itrQUAyCu0g2YPHaj30GkY6f20fC18HW2x1c0RHdTU0E5JGQO+MuJ1eaHLTb/drE09/8vzJ48R6uOJP48fhqKSMtyD9mCQsUmjNpUvynHmYBhO7t2J0qKHGD9hAn4PDXnrFw5CyD+ouJFW17FjRxgYGMDAoPHDznV1dcjLy2s0oSUzKwvnIvbhUUnj9S+flRSjn74huFwupIQZfBNy0m5BU0e31c7HGENCZAR2e6/Ey8pKfDNpKuat9Wu0g8Oz0kc4uXcXYvfvQXVVJX788Uc4OzujX79+rRYHIeKKihsRGmlpafTs2RM9e/bE+PHjG7327NmzhoKXlJSEiIgI3Lp0HvajDTDO0gajpv0IeRGuolFRXoY+g/Rb5VwP8nIQtNIFaVcT0bmrFrz2H4NWz08bvX48JAh/HIuAjIwM7Gxt4ejoiG7durXK9Qn5GNCNevJBUFFRgb6+PmbNmoVNmzbhwYMHSE9Px3gzU4T5eWHeyCEI3/wryp4+FlmM+iZjWtS/tqYGhwI3wnH8CNxJuYEfFrkiKP5KQ2HLTk3Brw7WcBgzHCkJp+GxciUKCwrg6+tLhY0QPtHIjXyw+vTpg927d2P16tXw9/fH9h3bcTwkCN9OnYGJVrborCm8L3xpGZkWPeOWkXQF25Y740FeDnp99gWWBu6BUsdOYIwh5UICIncG4PbVS9Dt2ROBgYGwtLSEnJxcK74DQj4uNHIjHzwtLS1s2LABhQUFcHdzReLJo1gw2hBb3BxRmH1HKDEotFdq1rN8L54/Q9BKFyy3mIxnj0rw88bt8DkQhXZKyvjzxBE4Tx6FtdYWkOXWICIiAlmZmbC1taXCRkgLUXEjbUanTp3g4eGBgvx8+P76K+5evwTH8d/glwVWuJOSJJBrMsYAoMmHqN/V72L0MdibGSH+cDgMzSYg5FIqvhw+EtG/BcPedBg2udhD7xMtnD17FteuXsWUKVMgJfUhTJ8hpO2j4kbaHEVFRTg6OiLn3j2EhITgWWEe3L+fAI9ZU5B8PqGhILWGp6XFAIBPB757n7R/K7lfCC+bH+HvNA8yHA7WHYiCtYc3jmzfjHnfDkWojydMjIcjOTkZsbExGDFiBC1kTEgro+JG2iwOhwMrKytkZKTjyJEjkOPWYq31DCz5nxkunjqO+vr6Fl8jL+M2AGDQN9/+Z9v6ujocDwmCw9ivkXr5Ir6zWQivsGNIOHoQdiOG4kRIICx/tEB2djbCwsIwcODAFsdHCOGNihtp8yQlJTF58mRcvXoF8fHx0NFUh/9iOziO/RqnD+xDbU11s8+dk54GANDu89k722Wn3oTL/0yxZ/1qdNXRhXtgKB79VQh7U0NciTkON9clKCgowObNm9GjR49mx0MIeT9U3IjYkJCQwMiRIxEXdxrXr1+HwZBB2OHpivkmXyEyeBsqX5Tzfc7cv0duTS1vVfXiBUK8V8Jt2lgUFxbAzGI2VFQ7Y81PM5B/OxkbNmxAQX4+PD09oaqq2qL3Rwh5f1TciFgaNGgQDkVEIDMzE5PGj0P4xl9gN2IIwjb44Pnj0vc+T056apOvXTsbi4VjjHBqXwg6qWtC45MeiAkLBbfsGcLCwpB99y4WLlyIdiJ8+JyQjxUVNyLW9PT0EBwcjNzcXNjZWCNmXzDsRg7FztVLUXK/8J19n5YUo/zpk7eOPy5+iF/s58JnvhWelZYCEhIoffgXumt0QUxMDFJSkjFjxgzI8Nh8lRAiHFTcyEeha9eu8PX1RWFBAZYvW4qrsSdgb2qITS72KLiTybPPvbRbjf5dX1+PU2G7sdDMCNfPnQYAMMb9++99V3Hu7FmYmprSzEdCPgBU3MhHpWPHjlixYgUK8vOxYcMG5N68jsUTR2LdvFnIvHGtUductFuQ+nsh4/y7mXCfPh671ixDdVUVpKWkYGtrizt37uBQRASGDBkiirdDCGkCFTfyUWrXrh0WLlyIe9nZ2LNnDyqKH2DZDHOs+HEykv6IB2MM99JuQV7h1d/LVlhMQm7GbSi0awd3d3fk5+cjKCgIvXr1EvE7IYTwQsWNfNRkZGQwa9Ys3E5NRWRkJBQlAW/bmXCePArp1y7jRdlzAICCggK8vbxQ9PAhvL29oa6uLuLICSHvQsWNELya6m9ubo7LlxORkJAAve5aqH5Z1bDGY25uLlxdXdG+fXsRR0oIeR9U3Aj5FwkJCRgbGyM2JgZlz5/jwYMHAF6thkIIaTuouBHSBAUFBVrImJA2ioobIYQQsdOs4hYQEIAePXpATk4O+vr6uHr16jvbR0REoHfv3pCTk8OAAQMQHR3drGAJIYSQ98F3cTtw4ACcnJzg4eGBGzdu4PPPP4epqSlKSkp4tr906RJ++OEHzJ07F8nJyZg0aRImTZqE27dvtzh4QgghhBe+i5u/vz+sra1hZWWFvn37IigoCAoKCggJCeHZftOmTTAzM4OLiwv69OmDNWvW4Msvv8TWrVtbHDwhhBDCizQ/jWtqapCUlAR3d/eGY5KSkjAxMUFiYiLPPomJiXBycmp0zNTUFJGRkU1ep7q6GtXV/2xTUlZWBgCora1FbW0tPyE3eN2vuf3FGeWmaZQb3igvTaPc8NZaeXnf/nwVt9LSUtTX10NNTa3RcTU1NWRm8l6fr6ioiGf7oqKiJq+zbt06rFq16q3jp0+fhoKCAj8hvyUuLq5F/cUZ5aZplBveKC9No9zw1tK8VFZWvlc7voqbsLi7uzca7ZWVlUFLSwujR4+GkpJSs85ZW1uLuLg4jBo1ilZrfwPlpmmUG94oL02j3PDWWnl5fSfvv/BV3FRVVSElJYXi4uJGx4uLi5tcjkhdXZ2v9gAgKysLWVnZt47LyMi0+MPSGucQV5SbplFueKO8NI1yw1tL8/K+ffmaUMLhcDBo0CDEx8c3HONyuYiPj4eBgQHPPgYGBo3aA6+GpU21J4QQQlqK79uSTk5OsLS0xODBgzF06FBs3LgRFRUVsLKyAgDMmjULXbt2xbp16wAAixYtgrGxMfz8/DBu3DiEh4fj+vXr2LFjR+u+E0IIIeRvfBe36dOn49GjR1i5ciWKioowcOBAxMTENEwaKSgogKTkPwNCQ0ND/P7771i+fDmWLl2KXr16ITIyEv3792+9d0EIIYT8S7MmlNjb28Pe3p7nawkJCW8dmzp1KqZOndqcSxFCCCF8o7UlCSGEiJ0P8lGANzHGALz/FFBeamtrUVlZibKyMprB9AbKTdMoN7xRXppGueGttfLyug68rgtNaRPFrby8HACgpaUl4kgIIYR8CMrLy6GsrNzk6xLsv8rfB4DL5eLBgwdo3749JCQkmnWO1w+CFxYWNvtBcHFFuWka5YY3ykvTKDe8tVZeGGMoLy+HpqZmo8mLb2oTIzdJSUl069atVc6lpKREH7gmUG6aRrnhjfLSNMoNb62Rl3eN2F6jCSWEEELEDhU3QgghYuejKW6ysrLw8PDguWblx45y0zTKDW+Ul6ZRbngTdl7axIQSQgghhB8fzciNEELIx4OKGyGEELFDxY0QQojYoeJGCCFE7FBxI4QQInbEqrgFBASgR48ekJOTg76+Pq5evfrO9hEREejduzfk5OQwYMAAREdHCylS4eMnNzt37sTw4cPRoUMHdOjQASYmJv+Zy7aK38/Ma+Hh4ZCQkMCkSZMEG6AI8ZubZ8+eYcGCBdDQ0ICsrCz09PTE9v8pfnOzceNGfPrpp5CXl4eWlhYWL16Mly9fCila4fjzzz8xYcIEaGpqQkJCApGRkf/ZJyEhAV9++SVkZWXRs2dPhIaGtl5ATEyEh4czDofDQkJCWFpaGrO2tmYqKiqsuLiYZ/uLFy8yKSkptn79epaens6WL1/OZGRkWGpqqpAjFzx+czNjxgwWEBDAkpOTWUZGBps9ezZTVlZm9+/fF3LkgsVvXl7Lzc1lXbt2ZcOHD2fm5ubCCVbI+M1NdXU1Gzx4MBs7diy7cOECy83NZQkJCSwlJUXIkQsev7kJCwtjsrKyLCwsjOXm5rLY2FimoaHBFi9eLOTIBSs6OpotW7aMHTlyhAFgR48efWf7nJwcpqCgwJycnFh6ejrbsmULk5KSYjExMa0Sj9gUt6FDh7IFCxY0/Lu+vp5pamqydevW8Ww/bdo0Nm7cuEbH9PX1ma2trUDjFAV+c/Omuro61r59e7Znzx5BhSgSzclLXV0dMzQ0ZLt27WKWlpZiW9z4zU1gYCDT0dFhNTU1wgpRZPjNzYIFC9jIkSMbHXNycmLDhg0TaJyi9D7FbcmSJaxfv36Njk2fPp2Zmpq2SgxicVuypqYGSUlJMDExaTgmKSkJExMTJCYm8uyTmJjYqD0AmJqaNtm+rWpObt5UWVmJ2tpadOzYUVBhCl1z87J69Wp06dIFc+fOFUaYItGc3Bw/fhwGBgZYsGAB1NTU0L9/f3h7e6O+vl5YYQtFc3JjaGiIpKSkhluXOTk5iI6OxtixY4US84dK0N/BbWJXgP9SWlqK+vp6qKmpNTqupqaGzMxMnn2Kiop4ti8qKhJYnKLQnNy8ydXVFZqamm99ENuy5uTlwoULCA4ORkpKihAiFJ3m5CYnJwdnz56FhYUFoqOjkZ2djfnz56O2thYeHh7CCFsompObGTNmoLS0FEZGRmCMoa6uDnZ2dli6dKkwQv5gNfUdXFZWhqqqKsjLy7fo/GIxciOC4+Pjg/DwcBw9ehRycnKiDkdkysvLMXPmTOzcuROqqqqiDueDw+Vy0aVLF+zYsQODBg3C9OnTsWzZMgQFBYk6NJFLSEiAt7c3tm3bhhs3buDIkSM4efIk1qxZI+rQxJpYjNxUVVUhJSWF4uLiRseLi4uhrq7Os4+6ujpf7duq5uTmNV9fX/j4+ODMmTP47LPPBBmm0PGbl3v37iEvLw8TJkxoOMblcgEA0tLSyMrKgq6urmCDFpLmfGY0NDQgIyMDKSmphmN9+vRBUVERampqwOFwBBqzsDQnNytWrMDMmTPx008/AQAGDBiAiooK2NjYYNmyZe/ccFOcNfUdrKSk1OJRGyAmIzcOh4NBgwYhPj6+4RiXy0V8fDwMDAx49jEwMGjUHgDi4uKabN9WNSc3ALB+/XqsWbMGMTExGDx4sDBCFSp+89K7d2+kpqYiJSWl4WfixIkYMWIEUlJSoKWlJczwBao5n5lhw4YhOzu7oeADwJ07d6ChoSE2hQ1oXm4qKyvfKmCvfwlgH/G69QL/Dm6VaSkfgPDwcCYrK8tCQ0NZeno6s7GxYSoqKqyoqIgxxtjMmTOZm5tbQ/uLFy8yaWlp5uvryzIyMpiHh4dYPwrAT258fHwYh8Nhhw4dYg8fPmz4KS8vF9VbEAh+8/ImcZ4tyW9uCgoKWPv27Zm9vT3LyspiUVFRrEuXLmzt2rWiegsCw29uPDw8WPv27dn+/ftZTk4OO336NNPV1WXTpk0T1VsQiPLycpacnMySk5MZAObv78+Sk5NZfn4+Y4wxNzc3NnPmzIb2rx8FcHFxYRkZGSwgIIAeBWjKli1b2CeffMI4HA4bOnQou3z5csNrxsbGzNLSslH7gwcPMj09PcbhcFi/fv3YyZMnhRyx8PCTm+7duzMAb/14eHgIP3AB4/cz82/iXNwY4z83ly5dYvr6+kxWVpbp6OgwLy8vVldXJ+SohYOf3NTW1jJPT0+mq6vL5OTkmJaWFps/fz57+vSp8AMXoHPnzvH83nidC0tLS2ZsbPxWn4EDBzIOh8N0dHTY7t27Wy0e2s+NEEKI2BGLv7kRQggh/0bFjRBCiNih4kYIIUTsUHEjhBAidqi4EUIIETtU3AghhIgdKm6EEELEDhU3QgghYoeKGyGEELFDxY0QQojYoeJGCCFE7PwfdD+8MHprvKQAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import triangle\n",
    "\n",
    "# 生成一个随机的二维多边形\n",
    "def generate_random_2d_polygon(num_vertices=6):\n",
    "    points = np.random.rand(num_vertices, 2)\n",
    "    center = np.mean(points, axis=0)\n",
    "    angles = np.arctan2(points[:, 1] - center[1], points[:, 0] - center[0])\n",
    "    points = points[np.argsort(angles)]\n",
    "    return points\n",
    "\n",
    "# 对多边形进行三角剖分\n",
    "def constrained_triangulation(polygon_points):\n",
    "    vertices = np.array(polygon_points)\n",
    "    # 定义约束边，保持多边形的边界不被破坏\n",
    "    segments = np.array([[i, (i + 1) % len(vertices)] for i in range(len(vertices))])\n",
    "    \n",
    "    # 使用 triangle 库进行带约束的三角剖分\n",
    "    A = dict(vertices=vertices, segments=segments)\n",
    "    triangulation = triangle.triangulate(A, 'p')\n",
    "    \n",
    "    return triangulation\n",
    "\n",
    "# 绘制三角剖分\n",
    "def plot_triangulation(triangulation):\n",
    "    plt.figure()\n",
    "    vertices = triangulation['vertices']\n",
    "    triangles = triangulation['triangles']\n",
    "    \n",
    "    for triangle in triangles:\n",
    "        t = vertices[triangle]\n",
    "        plt.fill(t[:, 0], t[:, 1], 'lightblue', edgecolor='k')\n",
    "    \n",
    "    plt.gca().set_aspect('equal')\n",
    "    plt.title(\"Constrained Triangulation with triangle Library\")\n",
    "    plt.grid(True)\n",
    "    plt.show()\n",
    "def generate_polygon_with_fixed_edges(fixed_edges, num_random_vertices=4):\n",
    "    # 提取固定边的顶点\n",
    "    fixed_points = np.vstack(fixed_edges)\n",
    "    \n",
    "    # 随机生成其余的点，满足 y > 0.4 或 y < 0.3\n",
    "    random_points = []\n",
    "    while len(random_points) < num_random_vertices:\n",
    "        point = np.random.rand(2)  # 生成一个随机点\n",
    "        if point[1] > 0.4 or point[1] < 0.3:  # 仅保留 y 坐标符合条件的点\n",
    "            random_points.append(point)\n",
    "    random_points = np.array(random_points)\n",
    "    \n",
    "    # 将固定的点和随机点合并在一起\n",
    "    all_points = np.vstack([fixed_points, random_points])\n",
    "    \n",
    "    # 计算所有点的中心点\n",
    "    center = np.mean(all_points, axis=0)\n",
    "    \n",
    "    # 按照与中心点的角度对所有点进行排序（确保按逆时针方向排列）\n",
    "    angles = np.arctan2(all_points[:, 1] - center[1], all_points[:, 0] - center[0])\n",
    "    sorted_points = all_points[np.argsort(angles)]\n",
    "    \n",
    "    # 使用 shapely 生成 Polygon\n",
    "    polygon = Polygon(sorted_points)\n",
    "    \n",
    "    return polygon, sorted_points\n",
    "# 主程序\n",
    "if __name__ == \"__main__\":\n",
    "    # 假设有两条固定的边\n",
    "    fixed_edge_1 = np.array([[0, 0.4], [0, 0.3]])  # 第一条固定边\n",
    "    fixed_edge_2 = np.array([[1, 0.4], [1, 0.3]])  # 第二条固定边\n",
    "    \n",
    "    # 生成一个随机多边形，包含固定的边，且随机点的y坐标满足要求\n",
    "    polygon, polygon_points = generate_polygon_with_fixed_edges([fixed_edge_1, fixed_edge_2], num_random_vertices=5)\n",
    "    \n",
    "    \n",
    "    # 进行带约束的三角剖分\n",
    "    triangulation = constrained_triangulation(polygon_points)\n",
    "    \n",
    "    # 绘制剖分结果\n",
    "    plot_triangulation(triangulation)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 把图形转换为obj"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OBJ 文件已生成：polygon_triangulated.obj\n"
     ]
    },
    {
     "data": {
      "application/vnd.plotly.v1+json": {
       "config": {
        "plotlyServerURL": "https://plot.ly"
       },
       "data": [
        {
         "color": "lightblue",
         "i": [
          6,
          5,
          2,
          4,
          2
         ],
         "j": [
          0,
          0,
          3,
          5,
          5
         ],
         "k": [
          5,
          1,
          5,
          3,
          1
         ],
         "opacity": 0.5,
         "type": "mesh3d",
         "x": [
          -12.108292042102535,
          -11.113844758137333,
          6.438397442732654,
          10.741481564441415,
          14.42988341084488,
          -0.46534707473635706,
          -7.287670312104986
         ],
         "y": [
          -5.459113889059248,
          -14.557035116759792,
          -13.786076964759687,
          -7.197070118686245,
          10.306973385196898,
          -2.073053688961636,
          10.237312561967176
         ],
         "z": [
          0,
          0,
          0,
          0,
          0,
          0,
          0
         ]
        }
       ],
       "layout": {
        "scene": {
         "xaxis": {
          "visible": false
         },
         "yaxis": {
          "visible": false
         },
         "zaxis": {
          "visible": false
         }
        },
        "template": {
         "data": {
          "bar": [
           {
            "error_x": {
             "color": "#2a3f5f"
            },
            "error_y": {
             "color": "#2a3f5f"
            },
            "marker": {
             "line": {
              "color": "#E5ECF6",
              "width": 0.5
             },
             "pattern": {
              "fillmode": "overlay",
              "size": 10,
              "solidity": 0.2
             }
            },
            "type": "bar"
           }
          ],
          "barpolar": [
           {
            "marker": {
             "line": {
              "color": "#E5ECF6",
              "width": 0.5
             },
             "pattern": {
              "fillmode": "overlay",
              "size": 10,
              "solidity": 0.2
             }
            },
            "type": "barpolar"
           }
          ],
          "carpet": [
           {
            "aaxis": {
             "endlinecolor": "#2a3f5f",
             "gridcolor": "white",
             "linecolor": "white",
             "minorgridcolor": "white",
             "startlinecolor": "#2a3f5f"
            },
            "baxis": {
             "endlinecolor": "#2a3f5f",
             "gridcolor": "white",
             "linecolor": "white",
             "minorgridcolor": "white",
             "startlinecolor": "#2a3f5f"
            },
            "type": "carpet"
           }
          ],
          "choropleth": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "type": "choropleth"
           }
          ],
          "contour": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "colorscale": [
             [
              0,
              "#0d0887"
             ],
             [
              0.1111111111111111,
              "#46039f"
             ],
             [
              0.2222222222222222,
              "#7201a8"
             ],
             [
              0.3333333333333333,
              "#9c179e"
             ],
             [
              0.4444444444444444,
              "#bd3786"
             ],
             [
              0.5555555555555556,
              "#d8576b"
             ],
             [
              0.6666666666666666,
              "#ed7953"
             ],
             [
              0.7777777777777778,
              "#fb9f3a"
             ],
             [
              0.8888888888888888,
              "#fdca26"
             ],
             [
              1,
              "#f0f921"
             ]
            ],
            "type": "contour"
           }
          ],
          "contourcarpet": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "type": "contourcarpet"
           }
          ],
          "heatmap": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "colorscale": [
             [
              0,
              "#0d0887"
             ],
             [
              0.1111111111111111,
              "#46039f"
             ],
             [
              0.2222222222222222,
              "#7201a8"
             ],
             [
              0.3333333333333333,
              "#9c179e"
             ],
             [
              0.4444444444444444,
              "#bd3786"
             ],
             [
              0.5555555555555556,
              "#d8576b"
             ],
             [
              0.6666666666666666,
              "#ed7953"
             ],
             [
              0.7777777777777778,
              "#fb9f3a"
             ],
             [
              0.8888888888888888,
              "#fdca26"
             ],
             [
              1,
              "#f0f921"
             ]
            ],
            "type": "heatmap"
           }
          ],
          "heatmapgl": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "colorscale": [
             [
              0,
              "#0d0887"
             ],
             [
              0.1111111111111111,
              "#46039f"
             ],
             [
              0.2222222222222222,
              "#7201a8"
             ],
             [
              0.3333333333333333,
              "#9c179e"
             ],
             [
              0.4444444444444444,
              "#bd3786"
             ],
             [
              0.5555555555555556,
              "#d8576b"
             ],
             [
              0.6666666666666666,
              "#ed7953"
             ],
             [
              0.7777777777777778,
              "#fb9f3a"
             ],
             [
              0.8888888888888888,
              "#fdca26"
             ],
             [
              1,
              "#f0f921"
             ]
            ],
            "type": "heatmapgl"
           }
          ],
          "histogram": [
           {
            "marker": {
             "pattern": {
              "fillmode": "overlay",
              "size": 10,
              "solidity": 0.2
             }
            },
            "type": "histogram"
           }
          ],
          "histogram2d": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "colorscale": [
             [
              0,
              "#0d0887"
             ],
             [
              0.1111111111111111,
              "#46039f"
             ],
             [
              0.2222222222222222,
              "#7201a8"
             ],
             [
              0.3333333333333333,
              "#9c179e"
             ],
             [
              0.4444444444444444,
              "#bd3786"
             ],
             [
              0.5555555555555556,
              "#d8576b"
             ],
             [
              0.6666666666666666,
              "#ed7953"
             ],
             [
              0.7777777777777778,
              "#fb9f3a"
             ],
             [
              0.8888888888888888,
              "#fdca26"
             ],
             [
              1,
              "#f0f921"
             ]
            ],
            "type": "histogram2d"
           }
          ],
          "histogram2dcontour": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "colorscale": [
             [
              0,
              "#0d0887"
             ],
             [
              0.1111111111111111,
              "#46039f"
             ],
             [
              0.2222222222222222,
              "#7201a8"
             ],
             [
              0.3333333333333333,
              "#9c179e"
             ],
             [
              0.4444444444444444,
              "#bd3786"
             ],
             [
              0.5555555555555556,
              "#d8576b"
             ],
             [
              0.6666666666666666,
              "#ed7953"
             ],
             [
              0.7777777777777778,
              "#fb9f3a"
             ],
             [
              0.8888888888888888,
              "#fdca26"
             ],
             [
              1,
              "#f0f921"
             ]
            ],
            "type": "histogram2dcontour"
           }
          ],
          "mesh3d": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "type": "mesh3d"
           }
          ],
          "parcoords": [
           {
            "line": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "parcoords"
           }
          ],
          "pie": [
           {
            "automargin": true,
            "type": "pie"
           }
          ],
          "scatter": [
           {
            "fillpattern": {
             "fillmode": "overlay",
             "size": 10,
             "solidity": 0.2
            },
            "type": "scatter"
           }
          ],
          "scatter3d": [
           {
            "line": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scatter3d"
           }
          ],
          "scattercarpet": [
           {
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scattercarpet"
           }
          ],
          "scattergeo": [
           {
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scattergeo"
           }
          ],
          "scattergl": [
           {
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scattergl"
           }
          ],
          "scattermapbox": [
           {
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scattermapbox"
           }
          ],
          "scatterpolar": [
           {
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scatterpolar"
           }
          ],
          "scatterpolargl": [
           {
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scatterpolargl"
           }
          ],
          "scatterternary": [
           {
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scatterternary"
           }
          ],
          "surface": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "colorscale": [
             [
              0,
              "#0d0887"
             ],
             [
              0.1111111111111111,
              "#46039f"
             ],
             [
              0.2222222222222222,
              "#7201a8"
             ],
             [
              0.3333333333333333,
              "#9c179e"
             ],
             [
              0.4444444444444444,
              "#bd3786"
             ],
             [
              0.5555555555555556,
              "#d8576b"
             ],
             [
              0.6666666666666666,
              "#ed7953"
             ],
             [
              0.7777777777777778,
              "#fb9f3a"
             ],
             [
              0.8888888888888888,
              "#fdca26"
             ],
             [
              1,
              "#f0f921"
             ]
            ],
            "type": "surface"
           }
          ],
          "table": [
           {
            "cells": {
             "fill": {
              "color": "#EBF0F8"
             },
             "line": {
              "color": "white"
             }
            },
            "header": {
             "fill": {
              "color": "#C8D4E3"
             },
             "line": {
              "color": "white"
             }
            },
            "type": "table"
           }
          ]
         },
         "layout": {
          "annotationdefaults": {
           "arrowcolor": "#2a3f5f",
           "arrowhead": 0,
           "arrowwidth": 1
          },
          "autotypenumbers": "strict",
          "coloraxis": {
           "colorbar": {
            "outlinewidth": 0,
            "ticks": ""
           }
          },
          "colorscale": {
           "diverging": [
            [
             0,
             "#8e0152"
            ],
            [
             0.1,
             "#c51b7d"
            ],
            [
             0.2,
             "#de77ae"
            ],
            [
             0.3,
             "#f1b6da"
            ],
            [
             0.4,
             "#fde0ef"
            ],
            [
             0.5,
             "#f7f7f7"
            ],
            [
             0.6,
             "#e6f5d0"
            ],
            [
             0.7,
             "#b8e186"
            ],
            [
             0.8,
             "#7fbc41"
            ],
            [
             0.9,
             "#4d9221"
            ],
            [
             1,
             "#276419"
            ]
           ],
           "sequential": [
            [
             0,
             "#0d0887"
            ],
            [
             0.1111111111111111,
             "#46039f"
            ],
            [
             0.2222222222222222,
             "#7201a8"
            ],
            [
             0.3333333333333333,
             "#9c179e"
            ],
            [
             0.4444444444444444,
             "#bd3786"
            ],
            [
             0.5555555555555556,
             "#d8576b"
            ],
            [
             0.6666666666666666,
             "#ed7953"
            ],
            [
             0.7777777777777778,
             "#fb9f3a"
            ],
            [
             0.8888888888888888,
             "#fdca26"
            ],
            [
             1,
             "#f0f921"
            ]
           ],
           "sequentialminus": [
            [
             0,
             "#0d0887"
            ],
            [
             0.1111111111111111,
             "#46039f"
            ],
            [
             0.2222222222222222,
             "#7201a8"
            ],
            [
             0.3333333333333333,
             "#9c179e"
            ],
            [
             0.4444444444444444,
             "#bd3786"
            ],
            [
             0.5555555555555556,
             "#d8576b"
            ],
            [
             0.6666666666666666,
             "#ed7953"
            ],
            [
             0.7777777777777778,
             "#fb9f3a"
            ],
            [
             0.8888888888888888,
             "#fdca26"
            ],
            [
             1,
             "#f0f921"
            ]
           ]
          },
          "colorway": [
           "#636efa",
           "#EF553B",
           "#00cc96",
           "#ab63fa",
           "#FFA15A",
           "#19d3f3",
           "#FF6692",
           "#B6E880",
           "#FF97FF",
           "#FECB52"
          ],
          "font": {
           "color": "#2a3f5f"
          },
          "geo": {
           "bgcolor": "white",
           "lakecolor": "white",
           "landcolor": "#E5ECF6",
           "showlakes": true,
           "showland": true,
           "subunitcolor": "white"
          },
          "hoverlabel": {
           "align": "left"
          },
          "hovermode": "closest",
          "mapbox": {
           "style": "light"
          },
          "paper_bgcolor": "white",
          "plot_bgcolor": "#E5ECF6",
          "polar": {
           "angularaxis": {
            "gridcolor": "white",
            "linecolor": "white",
            "ticks": ""
           },
           "bgcolor": "#E5ECF6",
           "radialaxis": {
            "gridcolor": "white",
            "linecolor": "white",
            "ticks": ""
           }
          },
          "scene": {
           "xaxis": {
            "backgroundcolor": "#E5ECF6",
            "gridcolor": "white",
            "gridwidth": 2,
            "linecolor": "white",
            "showbackground": true,
            "ticks": "",
            "zerolinecolor": "white"
           },
           "yaxis": {
            "backgroundcolor": "#E5ECF6",
            "gridcolor": "white",
            "gridwidth": 2,
            "linecolor": "white",
            "showbackground": true,
            "ticks": "",
            "zerolinecolor": "white"
           },
           "zaxis": {
            "backgroundcolor": "#E5ECF6",
            "gridcolor": "white",
            "gridwidth": 2,
            "linecolor": "white",
            "showbackground": true,
            "ticks": "",
            "zerolinecolor": "white"
           }
          },
          "shapedefaults": {
           "line": {
            "color": "#2a3f5f"
           }
          },
          "ternary": {
           "aaxis": {
            "gridcolor": "white",
            "linecolor": "white",
            "ticks": ""
           },
           "baxis": {
            "gridcolor": "white",
            "linecolor": "white",
            "ticks": ""
           },
           "bgcolor": "#E5ECF6",
           "caxis": {
            "gridcolor": "white",
            "linecolor": "white",
            "ticks": ""
           }
          },
          "title": {
           "x": 0.05
          },
          "xaxis": {
           "automargin": true,
           "gridcolor": "white",
           "linecolor": "white",
           "ticks": "",
           "title": {
            "standoff": 15
           },
           "zerolinecolor": "white",
           "zerolinewidth": 2
          },
          "yaxis": {
           "automargin": true,
           "gridcolor": "white",
           "linecolor": "white",
           "ticks": "",
           "title": {
            "standoff": 15
           },
           "zerolinecolor": "white",
           "zerolinewidth": 2
          }
         }
        },
        "title": {
         "text": "OBJ File Visualization"
        }
       }
      }
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import triangle\n",
    "\n",
    "# 生成一个随机的二维多边形\n",
    "def generate_random_2d_polygon(num_vertices=6):\n",
    "    #points = np.random.rand(num_vertices, 2)\n",
    "    points = np.random.uniform(-19, 19,size=(num_vertices, 2))\n",
    "    center = np.mean(points, axis=0)\n",
    "    angles = np.arctan2(points[:, 1] - center[1], points[:, 0] - center[0])\n",
    "    points = points[np.argsort(angles)]\n",
    "    return points\n",
    "\n",
    "# 对多边形进行三角剖分\n",
    "def constrained_triangulation(polygon_points):\n",
    "    vertices = np.array(polygon_points)\n",
    "    # 定义约束边，保持多边形的边界不被破坏\n",
    "    segments = np.array([[i, (i + 1) % len(vertices)] for i in range(len(vertices))])\n",
    "    \n",
    "    # 使用 triangle 库进行带约束的三角剖分\n",
    "    A = dict(vertices=vertices, segments=segments)\n",
    "    triangulation = triangle.triangulate(A, 'p')\n",
    "    \n",
    "    return triangulation\n",
    "\n",
    "# 将三角剖分结果保存为OBJ文件\n",
    "def export_to_obj(triangulation, filename=\"polygon_triangulated.obj\"):\n",
    "    vertices = triangulation['vertices']\n",
    "    triangles = triangulation['triangles']\n",
    "    \n",
    "    with open(filename, 'w') as f:\n",
    "        # 写入顶点信息\n",
    "        for v in vertices:\n",
    "            f.write(f\"v {v[0]} {v[1]} 0.0\\n\")  # z 设为 0 表示在二维平面上\n",
    "        \n",
    "        # 写入面（每个面由3个顶点构成）\n",
    "        for tri in triangles:\n",
    "            # OBJ 索引从1开始，因此要加1\n",
    "            f.write(f\"f {tri[0] + 1} {tri[1] + 1} {tri[2] + 1}\\n\")\n",
    "\n",
    "# 主程序\n",
    "if __name__ == \"__main__\":\n",
    "    num_vertices = 7  # 多边形的顶点数量\n",
    "    polygon_points = generate_random_2d_polygon(num_vertices)\n",
    "    \n",
    "    # 进行带约束的三角剖分\n",
    "    triangulation = constrained_triangulation(polygon_points)\n",
    "    \n",
    "    # 导出为OBJ文件\n",
    "    export_to_obj(triangulation, \"polygon_triangulated.obj\")\n",
    "    \n",
    "    print(\"OBJ 文件已生成：polygon_triangulated.obj\")\n",
    "\n",
    "\n",
    "import trimesh\n",
    "import plotly.graph_objects as go\n",
    "\n",
    "# 加载OBJ文件并转换为Plotly格式\n",
    "def plot_obj_in_jupyter(obj_filename):\n",
    "    # 使用trimesh加载OBJ文件\n",
    "    mesh = trimesh.load(obj_filename)\n",
    "    \n",
    "    # 获取顶点和面数据\n",
    "    vertices = mesh.vertices\n",
    "    faces = mesh.faces\n",
    "    \n",
    "    # 创建Plotly图形对象\n",
    "    mesh_plot = go.Mesh3d(\n",
    "        x=vertices[:, 0],\n",
    "        y=vertices[:, 1],\n",
    "        z=vertices[:, 2],\n",
    "        i=faces[:, 0],\n",
    "        j=faces[:, 1],\n",
    "        k=faces[:, 2],\n",
    "        opacity=0.5,\n",
    "        color='lightblue'\n",
    "    )\n",
    "    \n",
    "    # 设置布局\n",
    "    layout = go.Layout(\n",
    "        scene=dict(\n",
    "            xaxis=dict(visible=False),\n",
    "            yaxis=dict(visible=False),\n",
    "            zaxis=dict(visible=False)\n",
    "        ),\n",
    "        title=\"OBJ File Visualization\"\n",
    "    )\n",
    "    \n",
    "    # 创建并展示图像\n",
    "    fig = go.Figure(data=[mesh_plot], layout=layout)\n",
    "    fig.show()\n",
    "\n",
    "# 示例：展示生成的 OBJ 文件\n",
    "plot_obj_in_jupyter(\"polygon_triangulated.obj\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 固定两个点"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OBJ 文件已生成：polygon_triangulated.obj\n"
     ]
    },
    {
     "data": {
      "application/vnd.plotly.v1+json": {
       "config": {
        "plotlyServerURL": "https://plot.ly"
       },
       "data": [
        {
         "color": "lightblue",
         "i": [
          2,
          0,
          3,
          4,
          5,
          7,
          4
         ],
         "j": [
          3,
          1,
          8,
          5,
          7,
          5,
          8
         ],
         "k": [
          1,
          3,
          0,
          8,
          8,
          6,
          3
         ],
         "opacity": 0.5,
         "type": "mesh3d",
         "x": [
          -19.3,
          -19.3,
          -18.37672891273138,
          -12.906833810298743,
          19.3,
          19.3,
          7.153588756559245,
          4.071912865310704,
          -1.979919349840273
         ],
         "y": [
          0.73,
          -0.73,
          -4.335852160494566,
          -5.655964609291685,
          -0.73,
          0.73,
          18.765791100973274,
          14.944020337348626,
          6.548958754804801
         ],
         "z": [
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          0
         ]
        }
       ],
       "layout": {
        "scene": {
         "xaxis": {
          "visible": false
         },
         "yaxis": {
          "visible": false
         },
         "zaxis": {
          "visible": false
         }
        },
        "template": {
         "data": {
          "bar": [
           {
            "error_x": {
             "color": "#2a3f5f"
            },
            "error_y": {
             "color": "#2a3f5f"
            },
            "marker": {
             "line": {
              "color": "#E5ECF6",
              "width": 0.5
             },
             "pattern": {
              "fillmode": "overlay",
              "size": 10,
              "solidity": 0.2
             }
            },
            "type": "bar"
           }
          ],
          "barpolar": [
           {
            "marker": {
             "line": {
              "color": "#E5ECF6",
              "width": 0.5
             },
             "pattern": {
              "fillmode": "overlay",
              "size": 10,
              "solidity": 0.2
             }
            },
            "type": "barpolar"
           }
          ],
          "carpet": [
           {
            "aaxis": {
             "endlinecolor": "#2a3f5f",
             "gridcolor": "white",
             "linecolor": "white",
             "minorgridcolor": "white",
             "startlinecolor": "#2a3f5f"
            },
            "baxis": {
             "endlinecolor": "#2a3f5f",
             "gridcolor": "white",
             "linecolor": "white",
             "minorgridcolor": "white",
             "startlinecolor": "#2a3f5f"
            },
            "type": "carpet"
           }
          ],
          "choropleth": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "type": "choropleth"
           }
          ],
          "contour": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "colorscale": [
             [
              0,
              "#0d0887"
             ],
             [
              0.1111111111111111,
              "#46039f"
             ],
             [
              0.2222222222222222,
              "#7201a8"
             ],
             [
              0.3333333333333333,
              "#9c179e"
             ],
             [
              0.4444444444444444,
              "#bd3786"
             ],
             [
              0.5555555555555556,
              "#d8576b"
             ],
             [
              0.6666666666666666,
              "#ed7953"
             ],
             [
              0.7777777777777778,
              "#fb9f3a"
             ],
             [
              0.8888888888888888,
              "#fdca26"
             ],
             [
              1,
              "#f0f921"
             ]
            ],
            "type": "contour"
           }
          ],
          "contourcarpet": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "type": "contourcarpet"
           }
          ],
          "heatmap": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "colorscale": [
             [
              0,
              "#0d0887"
             ],
             [
              0.1111111111111111,
              "#46039f"
             ],
             [
              0.2222222222222222,
              "#7201a8"
             ],
             [
              0.3333333333333333,
              "#9c179e"
             ],
             [
              0.4444444444444444,
              "#bd3786"
             ],
             [
              0.5555555555555556,
              "#d8576b"
             ],
             [
              0.6666666666666666,
              "#ed7953"
             ],
             [
              0.7777777777777778,
              "#fb9f3a"
             ],
             [
              0.8888888888888888,
              "#fdca26"
             ],
             [
              1,
              "#f0f921"
             ]
            ],
            "type": "heatmap"
           }
          ],
          "heatmapgl": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "colorscale": [
             [
              0,
              "#0d0887"
             ],
             [
              0.1111111111111111,
              "#46039f"
             ],
             [
              0.2222222222222222,
              "#7201a8"
             ],
             [
              0.3333333333333333,
              "#9c179e"
             ],
             [
              0.4444444444444444,
              "#bd3786"
             ],
             [
              0.5555555555555556,
              "#d8576b"
             ],
             [
              0.6666666666666666,
              "#ed7953"
             ],
             [
              0.7777777777777778,
              "#fb9f3a"
             ],
             [
              0.8888888888888888,
              "#fdca26"
             ],
             [
              1,
              "#f0f921"
             ]
            ],
            "type": "heatmapgl"
           }
          ],
          "histogram": [
           {
            "marker": {
             "pattern": {
              "fillmode": "overlay",
              "size": 10,
              "solidity": 0.2
             }
            },
            "type": "histogram"
           }
          ],
          "histogram2d": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "colorscale": [
             [
              0,
              "#0d0887"
             ],
             [
              0.1111111111111111,
              "#46039f"
             ],
             [
              0.2222222222222222,
              "#7201a8"
             ],
             [
              0.3333333333333333,
              "#9c179e"
             ],
             [
              0.4444444444444444,
              "#bd3786"
             ],
             [
              0.5555555555555556,
              "#d8576b"
             ],
             [
              0.6666666666666666,
              "#ed7953"
             ],
             [
              0.7777777777777778,
              "#fb9f3a"
             ],
             [
              0.8888888888888888,
              "#fdca26"
             ],
             [
              1,
              "#f0f921"
             ]
            ],
            "type": "histogram2d"
           }
          ],
          "histogram2dcontour": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "colorscale": [
             [
              0,
              "#0d0887"
             ],
             [
              0.1111111111111111,
              "#46039f"
             ],
             [
              0.2222222222222222,
              "#7201a8"
             ],
             [
              0.3333333333333333,
              "#9c179e"
             ],
             [
              0.4444444444444444,
              "#bd3786"
             ],
             [
              0.5555555555555556,
              "#d8576b"
             ],
             [
              0.6666666666666666,
              "#ed7953"
             ],
             [
              0.7777777777777778,
              "#fb9f3a"
             ],
             [
              0.8888888888888888,
              "#fdca26"
             ],
             [
              1,
              "#f0f921"
             ]
            ],
            "type": "histogram2dcontour"
           }
          ],
          "mesh3d": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "type": "mesh3d"
           }
          ],
          "parcoords": [
           {
            "line": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "parcoords"
           }
          ],
          "pie": [
           {
            "automargin": true,
            "type": "pie"
           }
          ],
          "scatter": [
           {
            "fillpattern": {
             "fillmode": "overlay",
             "size": 10,
             "solidity": 0.2
            },
            "type": "scatter"
           }
          ],
          "scatter3d": [
           {
            "line": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scatter3d"
           }
          ],
          "scattercarpet": [
           {
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scattercarpet"
           }
          ],
          "scattergeo": [
           {
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scattergeo"
           }
          ],
          "scattergl": [
           {
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scattergl"
           }
          ],
          "scattermapbox": [
           {
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scattermapbox"
           }
          ],
          "scatterpolar": [
           {
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scatterpolar"
           }
          ],
          "scatterpolargl": [
           {
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scatterpolargl"
           }
          ],
          "scatterternary": [
           {
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scatterternary"
           }
          ],
          "surface": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "colorscale": [
             [
              0,
              "#0d0887"
             ],
             [
              0.1111111111111111,
              "#46039f"
             ],
             [
              0.2222222222222222,
              "#7201a8"
             ],
             [
              0.3333333333333333,
              "#9c179e"
             ],
             [
              0.4444444444444444,
              "#bd3786"
             ],
             [
              0.5555555555555556,
              "#d8576b"
             ],
             [
              0.6666666666666666,
              "#ed7953"
             ],
             [
              0.7777777777777778,
              "#fb9f3a"
             ],
             [
              0.8888888888888888,
              "#fdca26"
             ],
             [
              1,
              "#f0f921"
             ]
            ],
            "type": "surface"
           }
          ],
          "table": [
           {
            "cells": {
             "fill": {
              "color": "#EBF0F8"
             },
             "line": {
              "color": "white"
             }
            },
            "header": {
             "fill": {
              "color": "#C8D4E3"
             },
             "line": {
              "color": "white"
             }
            },
            "type": "table"
           }
          ]
         },
         "layout": {
          "annotationdefaults": {
           "arrowcolor": "#2a3f5f",
           "arrowhead": 0,
           "arrowwidth": 1
          },
          "autotypenumbers": "strict",
          "coloraxis": {
           "colorbar": {
            "outlinewidth": 0,
            "ticks": ""
           }
          },
          "colorscale": {
           "diverging": [
            [
             0,
             "#8e0152"
            ],
            [
             0.1,
             "#c51b7d"
            ],
            [
             0.2,
             "#de77ae"
            ],
            [
             0.3,
             "#f1b6da"
            ],
            [
             0.4,
             "#fde0ef"
            ],
            [
             0.5,
             "#f7f7f7"
            ],
            [
             0.6,
             "#e6f5d0"
            ],
            [
             0.7,
             "#b8e186"
            ],
            [
             0.8,
             "#7fbc41"
            ],
            [
             0.9,
             "#4d9221"
            ],
            [
             1,
             "#276419"
            ]
           ],
           "sequential": [
            [
             0,
             "#0d0887"
            ],
            [
             0.1111111111111111,
             "#46039f"
            ],
            [
             0.2222222222222222,
             "#7201a8"
            ],
            [
             0.3333333333333333,
             "#9c179e"
            ],
            [
             0.4444444444444444,
             "#bd3786"
            ],
            [
             0.5555555555555556,
             "#d8576b"
            ],
            [
             0.6666666666666666,
             "#ed7953"
            ],
            [
             0.7777777777777778,
             "#fb9f3a"
            ],
            [
             0.8888888888888888,
             "#fdca26"
            ],
            [
             1,
             "#f0f921"
            ]
           ],
           "sequentialminus": [
            [
             0,
             "#0d0887"
            ],
            [
             0.1111111111111111,
             "#46039f"
            ],
            [
             0.2222222222222222,
             "#7201a8"
            ],
            [
             0.3333333333333333,
             "#9c179e"
            ],
            [
             0.4444444444444444,
             "#bd3786"
            ],
            [
             0.5555555555555556,
             "#d8576b"
            ],
            [
             0.6666666666666666,
             "#ed7953"
            ],
            [
             0.7777777777777778,
             "#fb9f3a"
            ],
            [
             0.8888888888888888,
             "#fdca26"
            ],
            [
             1,
             "#f0f921"
            ]
           ]
          },
          "colorway": [
           "#636efa",
           "#EF553B",
           "#00cc96",
           "#ab63fa",
           "#FFA15A",
           "#19d3f3",
           "#FF6692",
           "#B6E880",
           "#FF97FF",
           "#FECB52"
          ],
          "font": {
           "color": "#2a3f5f"
          },
          "geo": {
           "bgcolor": "white",
           "lakecolor": "white",
           "landcolor": "#E5ECF6",
           "showlakes": true,
           "showland": true,
           "subunitcolor": "white"
          },
          "hoverlabel": {
           "align": "left"
          },
          "hovermode": "closest",
          "mapbox": {
           "style": "light"
          },
          "paper_bgcolor": "white",
          "plot_bgcolor": "#E5ECF6",
          "polar": {
           "angularaxis": {
            "gridcolor": "white",
            "linecolor": "white",
            "ticks": ""
           },
           "bgcolor": "#E5ECF6",
           "radialaxis": {
            "gridcolor": "white",
            "linecolor": "white",
            "ticks": ""
           }
          },
          "scene": {
           "xaxis": {
            "backgroundcolor": "#E5ECF6",
            "gridcolor": "white",
            "gridwidth": 2,
            "linecolor": "white",
            "showbackground": true,
            "ticks": "",
            "zerolinecolor": "white"
           },
           "yaxis": {
            "backgroundcolor": "#E5ECF6",
            "gridcolor": "white",
            "gridwidth": 2,
            "linecolor": "white",
            "showbackground": true,
            "ticks": "",
            "zerolinecolor": "white"
           },
           "zaxis": {
            "backgroundcolor": "#E5ECF6",
            "gridcolor": "white",
            "gridwidth": 2,
            "linecolor": "white",
            "showbackground": true,
            "ticks": "",
            "zerolinecolor": "white"
           }
          },
          "shapedefaults": {
           "line": {
            "color": "#2a3f5f"
           }
          },
          "ternary": {
           "aaxis": {
            "gridcolor": "white",
            "linecolor": "white",
            "ticks": ""
           },
           "baxis": {
            "gridcolor": "white",
            "linecolor": "white",
            "ticks": ""
           },
           "bgcolor": "#E5ECF6",
           "caxis": {
            "gridcolor": "white",
            "linecolor": "white",
            "ticks": ""
           }
          },
          "title": {
           "x": 0.05
          },
          "xaxis": {
           "automargin": true,
           "gridcolor": "white",
           "linecolor": "white",
           "ticks": "",
           "title": {
            "standoff": 15
           },
           "zerolinecolor": "white",
           "zerolinewidth": 2
          },
          "yaxis": {
           "automargin": true,
           "gridcolor": "white",
           "linecolor": "white",
           "ticks": "",
           "title": {
            "standoff": 15
           },
           "zerolinecolor": "white",
           "zerolinewidth": 2
          }
         }
        },
        "title": {
         "text": "OBJ File Visualization"
        }
       }
      }
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import triangle\n",
    "import numpy as np\n",
    "from shapely.geometry import Polygon\n",
    "import matplotlib.pyplot as plt\n",
    "# 生成一个随机的二维多边形\n",
    "def generate_random_2d_polygon(num_vertices=6):\n",
    "    #points = np.random.rand(num_vertices, 2)\n",
    "    points = np.random.uniform(-19, 19,size=(num_vertices, 2))\n",
    "    center = np.mean(points, axis=0)\n",
    "    angles = np.arctan2(points[:, 1] - center[1], points[:, 0] - center[0])\n",
    "    points = points[np.argsort(angles)]\n",
    "    return points\n",
    "\n",
    "\n",
    "# 生成包含已知边的随机二维多边形（y坐标要大于0.4或者小于0.3）\n",
    "def generate_polygon_with_fixed_edges(fixed_edges, num_random_vertices=4):\n",
    "    # 提取固定边的顶点\n",
    "    fixed_points = np.vstack(fixed_edges)\n",
    "    \n",
    "    # 随机生成其余的点，满足 y > 0.4 或 y < 0.3\n",
    "    random_points = []\n",
    "    while len(random_points) < num_random_vertices:\n",
    "        #point = np.random.rand(2)  # 生成一个随机点\n",
    "        point = np.random.uniform(-19, 19,size=2)\n",
    "        #if point[1] > 0.4 or point[1] < 0.3:  # 仅保留 y 坐标符合条件的点\n",
    "        random_points.append(point)\n",
    "    random_points = np.array(random_points)\n",
    "    \n",
    "    # 将固定的点和随机点合并在一起\n",
    "    all_points = np.vstack([fixed_points, random_points])\n",
    "    \n",
    "    # 计算所有点的中心点\n",
    "    center = np.mean(all_points, axis=0)\n",
    "    \n",
    "    # 按照与中心点的角度对所有点进行排序（确保按逆时针方向排列）\n",
    "    angles = np.arctan2(all_points[:, 1] - center[1], all_points[:, 0] - center[0])\n",
    "    sorted_points = all_points[np.argsort(angles)]\n",
    "    \n",
    "    # 使用 shapely 生成 Polygon\n",
    "    polygon = Polygon(sorted_points)\n",
    "    \n",
    "    return polygon, sorted_points\n",
    "# 对多边形进行三角剖分\n",
    "def constrained_triangulation(polygon_points):\n",
    "    vertices = np.array(polygon_points)\n",
    "    # 定义约束边，保持多边形的边界不被破坏\n",
    "    segments = np.array([[i, (i + 1) % len(vertices)] for i in range(len(vertices))])\n",
    "    \n",
    "    # 使用 triangle 库进行带约束的三角剖分\n",
    "    A = dict(vertices=vertices, segments=segments)\n",
    "    triangulation = triangle.triangulate(A, 'p')\n",
    "    \n",
    "    return triangulation\n",
    "\n",
    "# 将三角剖分结果保存为OBJ文件\n",
    "def export_to_obj(triangulation, filename=\"polygon_triangulated.obj\"):\n",
    "    vertices = triangulation['vertices']\n",
    "    triangles = triangulation['triangles']\n",
    "    \n",
    "    with open(filename, 'w') as f:\n",
    "        # 写入顶点信息\n",
    "        for v in vertices:\n",
    "            f.write(f\"v {v[0]} {v[1]} 0.0\\n\")  # z 设为 0 表示在二维平面上\n",
    "        \n",
    "        # 写入面（每个面由3个顶点构成）\n",
    "        for tri in triangles:\n",
    "            # OBJ 索引从1开始，因此要加1\n",
    "            f.write(f\"f {tri[0] + 1} {tri[1] + 1} {tri[2] + 1}\\n\")\n",
    "\n",
    "# 主程序\n",
    "if __name__ == \"__main__\":\n",
    "    # 假设有两条固定的边\n",
    "    fixed_edge_1 = np.array([[19.3, 0.73], [19.3, -0.73]])  # 第一条固定边\n",
    "    fixed_edge_2 = np.array([[-19.3, 0.73], [-19.3, -0.73]])  # 第二条固定边\n",
    "\n",
    "    #polygon_points = generate_random_2d_polygon(num_vertices)\n",
    "\n",
    "    # 生成一个随机多边形，包含固定的边，且随机点的y坐标满足要求\n",
    "    polygon, sorted_points = generate_polygon_with_fixed_edges([fixed_edge_1, fixed_edge_2], num_random_vertices=5)\n",
    "\n",
    "    # 进行带约束的三角剖分\n",
    "    triangulation = constrained_triangulation(sorted_points)\n",
    "    \n",
    "    # 导出为OBJ文件\n",
    "    export_to_obj(triangulation, \"polygon_triangulated3.obj\")\n",
    "    \n",
    "    print(\"OBJ 文件已生成：polygon_triangulated.obj\")\n",
    "\n",
    "\n",
    "import trimesh\n",
    "import plotly.graph_objects as go\n",
    "\n",
    "# 加载OBJ文件并转换为Plotly格式\n",
    "def plot_obj_in_jupyter(obj_filename):\n",
    "    # 使用trimesh加载OBJ文件\n",
    "    mesh = trimesh.load(obj_filename)\n",
    "    \n",
    "    # 获取顶点和面数据\n",
    "    vertices = mesh.vertices\n",
    "    faces = mesh.faces\n",
    "    \n",
    "    # 创建Plotly图形对象\n",
    "    mesh_plot = go.Mesh3d(\n",
    "        x=vertices[:, 0],\n",
    "        y=vertices[:, 1],\n",
    "        z=vertices[:, 2],\n",
    "        i=faces[:, 0],\n",
    "        j=faces[:, 1],\n",
    "        k=faces[:, 2],\n",
    "        opacity=0.5,\n",
    "        color='lightblue'\n",
    "    )\n",
    "    \n",
    "    # 设置布局\n",
    "    layout = go.Layout(\n",
    "        scene=dict(\n",
    "            xaxis=dict(visible=False),\n",
    "            yaxis=dict(visible=False),\n",
    "            zaxis=dict(visible=False)\n",
    "        ),\n",
    "        title=\"OBJ File Visualization\"\n",
    "    )\n",
    "    \n",
    "    # 创建并展示图像\n",
    "    fig = go.Figure(data=[mesh_plot], layout=layout)\n",
    "    fig.show()\n",
    "\n",
    "# 示例：展示生成的 OBJ 文件\n",
    "plot_obj_in_jupyter(\"polygon_triangulated3.obj\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.plotly.v1+json": {
       "config": {
        "plotlyServerURL": "https://plot.ly"
       },
       "data": [
        {
         "color": "lightblue",
         "i": [
          0,
          7,
          1,
          3,
          3,
          5,
          3
         ],
         "j": [
          1,
          8,
          3,
          6,
          5,
          3,
          1
         ],
         "k": [
          8,
          1,
          7,
          7,
          6,
          4,
          2
         ],
         "opacity": 0.5,
         "type": "mesh3d",
         "x": [
          -19.3,
          -18.343171013528238,
          -1.8090441973097136,
          2.787400676422596,
          19.3,
          19.3,
          14.473114945730025,
          -18.53930618127825,
          -19.3
         ],
         "y": [
          -0.73,
          -1.5691789375952645,
          -10.966525243890802,
          -5.994591870419056,
          -0.73,
          0.73,
          10.995136049302769,
          5.332436043023328,
          0.73
         ],
         "z": [
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          0,
          0
         ]
        }
       ],
       "layout": {
        "scene": {
         "xaxis": {
          "visible": false
         },
         "yaxis": {
          "visible": false
         },
         "zaxis": {
          "visible": false
         }
        },
        "template": {
         "data": {
          "bar": [
           {
            "error_x": {
             "color": "#2a3f5f"
            },
            "error_y": {
             "color": "#2a3f5f"
            },
            "marker": {
             "line": {
              "color": "#E5ECF6",
              "width": 0.5
             },
             "pattern": {
              "fillmode": "overlay",
              "size": 10,
              "solidity": 0.2
             }
            },
            "type": "bar"
           }
          ],
          "barpolar": [
           {
            "marker": {
             "line": {
              "color": "#E5ECF6",
              "width": 0.5
             },
             "pattern": {
              "fillmode": "overlay",
              "size": 10,
              "solidity": 0.2
             }
            },
            "type": "barpolar"
           }
          ],
          "carpet": [
           {
            "aaxis": {
             "endlinecolor": "#2a3f5f",
             "gridcolor": "white",
             "linecolor": "white",
             "minorgridcolor": "white",
             "startlinecolor": "#2a3f5f"
            },
            "baxis": {
             "endlinecolor": "#2a3f5f",
             "gridcolor": "white",
             "linecolor": "white",
             "minorgridcolor": "white",
             "startlinecolor": "#2a3f5f"
            },
            "type": "carpet"
           }
          ],
          "choropleth": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "type": "choropleth"
           }
          ],
          "contour": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "colorscale": [
             [
              0,
              "#0d0887"
             ],
             [
              0.1111111111111111,
              "#46039f"
             ],
             [
              0.2222222222222222,
              "#7201a8"
             ],
             [
              0.3333333333333333,
              "#9c179e"
             ],
             [
              0.4444444444444444,
              "#bd3786"
             ],
             [
              0.5555555555555556,
              "#d8576b"
             ],
             [
              0.6666666666666666,
              "#ed7953"
             ],
             [
              0.7777777777777778,
              "#fb9f3a"
             ],
             [
              0.8888888888888888,
              "#fdca26"
             ],
             [
              1,
              "#f0f921"
             ]
            ],
            "type": "contour"
           }
          ],
          "contourcarpet": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "type": "contourcarpet"
           }
          ],
          "heatmap": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "colorscale": [
             [
              0,
              "#0d0887"
             ],
             [
              0.1111111111111111,
              "#46039f"
             ],
             [
              0.2222222222222222,
              "#7201a8"
             ],
             [
              0.3333333333333333,
              "#9c179e"
             ],
             [
              0.4444444444444444,
              "#bd3786"
             ],
             [
              0.5555555555555556,
              "#d8576b"
             ],
             [
              0.6666666666666666,
              "#ed7953"
             ],
             [
              0.7777777777777778,
              "#fb9f3a"
             ],
             [
              0.8888888888888888,
              "#fdca26"
             ],
             [
              1,
              "#f0f921"
             ]
            ],
            "type": "heatmap"
           }
          ],
          "heatmapgl": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "colorscale": [
             [
              0,
              "#0d0887"
             ],
             [
              0.1111111111111111,
              "#46039f"
             ],
             [
              0.2222222222222222,
              "#7201a8"
             ],
             [
              0.3333333333333333,
              "#9c179e"
             ],
             [
              0.4444444444444444,
              "#bd3786"
             ],
             [
              0.5555555555555556,
              "#d8576b"
             ],
             [
              0.6666666666666666,
              "#ed7953"
             ],
             [
              0.7777777777777778,
              "#fb9f3a"
             ],
             [
              0.8888888888888888,
              "#fdca26"
             ],
             [
              1,
              "#f0f921"
             ]
            ],
            "type": "heatmapgl"
           }
          ],
          "histogram": [
           {
            "marker": {
             "pattern": {
              "fillmode": "overlay",
              "size": 10,
              "solidity": 0.2
             }
            },
            "type": "histogram"
           }
          ],
          "histogram2d": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "colorscale": [
             [
              0,
              "#0d0887"
             ],
             [
              0.1111111111111111,
              "#46039f"
             ],
             [
              0.2222222222222222,
              "#7201a8"
             ],
             [
              0.3333333333333333,
              "#9c179e"
             ],
             [
              0.4444444444444444,
              "#bd3786"
             ],
             [
              0.5555555555555556,
              "#d8576b"
             ],
             [
              0.6666666666666666,
              "#ed7953"
             ],
             [
              0.7777777777777778,
              "#fb9f3a"
             ],
             [
              0.8888888888888888,
              "#fdca26"
             ],
             [
              1,
              "#f0f921"
             ]
            ],
            "type": "histogram2d"
           }
          ],
          "histogram2dcontour": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "colorscale": [
             [
              0,
              "#0d0887"
             ],
             [
              0.1111111111111111,
              "#46039f"
             ],
             [
              0.2222222222222222,
              "#7201a8"
             ],
             [
              0.3333333333333333,
              "#9c179e"
             ],
             [
              0.4444444444444444,
              "#bd3786"
             ],
             [
              0.5555555555555556,
              "#d8576b"
             ],
             [
              0.6666666666666666,
              "#ed7953"
             ],
             [
              0.7777777777777778,
              "#fb9f3a"
             ],
             [
              0.8888888888888888,
              "#fdca26"
             ],
             [
              1,
              "#f0f921"
             ]
            ],
            "type": "histogram2dcontour"
           }
          ],
          "mesh3d": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "type": "mesh3d"
           }
          ],
          "parcoords": [
           {
            "line": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "parcoords"
           }
          ],
          "pie": [
           {
            "automargin": true,
            "type": "pie"
           }
          ],
          "scatter": [
           {
            "fillpattern": {
             "fillmode": "overlay",
             "size": 10,
             "solidity": 0.2
            },
            "type": "scatter"
           }
          ],
          "scatter3d": [
           {
            "line": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scatter3d"
           }
          ],
          "scattercarpet": [
           {
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scattercarpet"
           }
          ],
          "scattergeo": [
           {
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scattergeo"
           }
          ],
          "scattergl": [
           {
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scattergl"
           }
          ],
          "scattermapbox": [
           {
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scattermapbox"
           }
          ],
          "scatterpolar": [
           {
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scatterpolar"
           }
          ],
          "scatterpolargl": [
           {
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scatterpolargl"
           }
          ],
          "scatterternary": [
           {
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scatterternary"
           }
          ],
          "surface": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "colorscale": [
             [
              0,
              "#0d0887"
             ],
             [
              0.1111111111111111,
              "#46039f"
             ],
             [
              0.2222222222222222,
              "#7201a8"
             ],
             [
              0.3333333333333333,
              "#9c179e"
             ],
             [
              0.4444444444444444,
              "#bd3786"
             ],
             [
              0.5555555555555556,
              "#d8576b"
             ],
             [
              0.6666666666666666,
              "#ed7953"
             ],
             [
              0.7777777777777778,
              "#fb9f3a"
             ],
             [
              0.8888888888888888,
              "#fdca26"
             ],
             [
              1,
              "#f0f921"
             ]
            ],
            "type": "surface"
           }
          ],
          "table": [
           {
            "cells": {
             "fill": {
              "color": "#EBF0F8"
             },
             "line": {
              "color": "white"
             }
            },
            "header": {
             "fill": {
              "color": "#C8D4E3"
             },
             "line": {
              "color": "white"
             }
            },
            "type": "table"
           }
          ]
         },
         "layout": {
          "annotationdefaults": {
           "arrowcolor": "#2a3f5f",
           "arrowhead": 0,
           "arrowwidth": 1
          },
          "autotypenumbers": "strict",
          "coloraxis": {
           "colorbar": {
            "outlinewidth": 0,
            "ticks": ""
           }
          },
          "colorscale": {
           "diverging": [
            [
             0,
             "#8e0152"
            ],
            [
             0.1,
             "#c51b7d"
            ],
            [
             0.2,
             "#de77ae"
            ],
            [
             0.3,
             "#f1b6da"
            ],
            [
             0.4,
             "#fde0ef"
            ],
            [
             0.5,
             "#f7f7f7"
            ],
            [
             0.6,
             "#e6f5d0"
            ],
            [
             0.7,
             "#b8e186"
            ],
            [
             0.8,
             "#7fbc41"
            ],
            [
             0.9,
             "#4d9221"
            ],
            [
             1,
             "#276419"
            ]
           ],
           "sequential": [
            [
             0,
             "#0d0887"
            ],
            [
             0.1111111111111111,
             "#46039f"
            ],
            [
             0.2222222222222222,
             "#7201a8"
            ],
            [
             0.3333333333333333,
             "#9c179e"
            ],
            [
             0.4444444444444444,
             "#bd3786"
            ],
            [
             0.5555555555555556,
             "#d8576b"
            ],
            [
             0.6666666666666666,
             "#ed7953"
            ],
            [
             0.7777777777777778,
             "#fb9f3a"
            ],
            [
             0.8888888888888888,
             "#fdca26"
            ],
            [
             1,
             "#f0f921"
            ]
           ],
           "sequentialminus": [
            [
             0,
             "#0d0887"
            ],
            [
             0.1111111111111111,
             "#46039f"
            ],
            [
             0.2222222222222222,
             "#7201a8"
            ],
            [
             0.3333333333333333,
             "#9c179e"
            ],
            [
             0.4444444444444444,
             "#bd3786"
            ],
            [
             0.5555555555555556,
             "#d8576b"
            ],
            [
             0.6666666666666666,
             "#ed7953"
            ],
            [
             0.7777777777777778,
             "#fb9f3a"
            ],
            [
             0.8888888888888888,
             "#fdca26"
            ],
            [
             1,
             "#f0f921"
            ]
           ]
          },
          "colorway": [
           "#636efa",
           "#EF553B",
           "#00cc96",
           "#ab63fa",
           "#FFA15A",
           "#19d3f3",
           "#FF6692",
           "#B6E880",
           "#FF97FF",
           "#FECB52"
          ],
          "font": {
           "color": "#2a3f5f"
          },
          "geo": {
           "bgcolor": "white",
           "lakecolor": "white",
           "landcolor": "#E5ECF6",
           "showlakes": true,
           "showland": true,
           "subunitcolor": "white"
          },
          "hoverlabel": {
           "align": "left"
          },
          "hovermode": "closest",
          "mapbox": {
           "style": "light"
          },
          "paper_bgcolor": "white",
          "plot_bgcolor": "#E5ECF6",
          "polar": {
           "angularaxis": {
            "gridcolor": "white",
            "linecolor": "white",
            "ticks": ""
           },
           "bgcolor": "#E5ECF6",
           "radialaxis": {
            "gridcolor": "white",
            "linecolor": "white",
            "ticks": ""
           }
          },
          "scene": {
           "xaxis": {
            "backgroundcolor": "#E5ECF6",
            "gridcolor": "white",
            "gridwidth": 2,
            "linecolor": "white",
            "showbackground": true,
            "ticks": "",
            "zerolinecolor": "white"
           },
           "yaxis": {
            "backgroundcolor": "#E5ECF6",
            "gridcolor": "white",
            "gridwidth": 2,
            "linecolor": "white",
            "showbackground": true,
            "ticks": "",
            "zerolinecolor": "white"
           },
           "zaxis": {
            "backgroundcolor": "#E5ECF6",
            "gridcolor": "white",
            "gridwidth": 2,
            "linecolor": "white",
            "showbackground": true,
            "ticks": "",
            "zerolinecolor": "white"
           }
          },
          "shapedefaults": {
           "line": {
            "color": "#2a3f5f"
           }
          },
          "ternary": {
           "aaxis": {
            "gridcolor": "white",
            "linecolor": "white",
            "ticks": ""
           },
           "baxis": {
            "gridcolor": "white",
            "linecolor": "white",
            "ticks": ""
           },
           "bgcolor": "#E5ECF6",
           "caxis": {
            "gridcolor": "white",
            "linecolor": "white",
            "ticks": ""
           }
          },
          "title": {
           "x": 0.05
          },
          "xaxis": {
           "automargin": true,
           "gridcolor": "white",
           "linecolor": "white",
           "ticks": "",
           "title": {
            "standoff": 15
           },
           "zerolinecolor": "white",
           "zerolinewidth": 2
          },
          "yaxis": {
           "automargin": true,
           "gridcolor": "white",
           "linecolor": "white",
           "ticks": "",
           "title": {
            "standoff": 15
           },
           "zerolinecolor": "white",
           "zerolinewidth": 2
          }
         }
        },
        "title": {
         "text": "OBJ File Visualization"
        }
       }
      }
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import trimesh\n",
    "import plotly.graph_objects as go\n",
    "\n",
    "# 加载OBJ文件并转换为Plotly格式\n",
    "def plot_obj_in_jupyter(obj_filename):\n",
    "    # 使用trimesh加载OBJ文件\n",
    "    mesh = trimesh.load(obj_filename)\n",
    "    \n",
    "    # 获取顶点和面数据\n",
    "    vertices = mesh.vertices\n",
    "    faces = mesh.faces\n",
    "    \n",
    "    # 创建Plotly图形对象\n",
    "    mesh_plot = go.Mesh3d(\n",
    "        x=vertices[:, 0],\n",
    "        y=vertices[:, 1],\n",
    "        z=vertices[:, 2],\n",
    "        i=faces[:, 0],\n",
    "        j=faces[:, 1],\n",
    "        k=faces[:, 2],\n",
    "        opacity=0.5,\n",
    "        color='lightblue'\n",
    "    )\n",
    "    \n",
    "    # 设置布局\n",
    "    layout = go.Layout(\n",
    "        scene=dict(\n",
    "            xaxis=dict(visible=False),\n",
    "            yaxis=dict(visible=False),\n",
    "            zaxis=dict(visible=False)\n",
    "        ),\n",
    "        title=\"OBJ File Visualization\"\n",
    "    )\n",
    "    \n",
    "    # 创建并展示图像\n",
    "    fig = go.Figure(data=[mesh_plot], layout=layout)\n",
    "    fig.show()\n",
    "\n",
    "# 示例：展示生成的 OBJ 文件\n",
    "plot_obj_in_jupyter(\"C:\\Reaserch\\Code\\CEM\\AntennaGPT\\data\\data0.obj\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np \n",
    "\n",
    "import triangle\n",
    "\n",
    "from shapely.geometry import Polygon\n",
    "import matplotlib.pyplot as plt\n",
    "import os\n",
    "import sys\n",
    "\n",
    "\n",
    "import trimesh\n",
    "import plotly.graph_objects as go\n",
    "from tqdm import tqdm\n",
    "# 测试把变化的点换成有间隔\n",
    "def generate_polygon_with_fixed_edges(fixed_edges, num_random_vertices=4):\n",
    "    # 提取固定边的顶点\n",
    "    fixed_points = np.vstack(fixed_edges)\n",
    "    # 随机生成其余的点，满足 y > 0.4 或 y < 0.3\n",
    "    random_points = []\n",
    "    while len(random_points) < num_random_vertices:\n",
    "        #point = np.random.rand(2)  # 生成一个随机点\n",
    "        point = np.random.uniform(-19, 19,size=2)\n",
    "        #if point[1] > 0.4 or point[1] < 0.3:  # 仅保留 y 坐标符合条件的点\n",
    "        random_points.append(point)\n",
    "    random_points = np.array(random_points)\n",
    "    \n",
    "    # 将固定的点和随机点合并在一起\n",
    "    all_points = np.vstack([fixed_points, random_points])\n",
    "    \n",
    "    # 计算所有点的中心点\n",
    "    center = np.mean(all_points, axis=0)\n",
    "    \n",
    "    # 按照与中心点的角度对所有点进行排序（确保按逆时针方向排列）\n",
    "    angles = np.arctan2(all_points[:, 1] - center[1], all_points[:, 0] - center[0])\n",
    "    sorted_points = all_points[np.argsort(angles)]\n",
    "    \n",
    "    # 使用 shapely 生成 Polygon\n",
    "    polygon = Polygon(sorted_points)\n",
    "    \n",
    "    return polygon, sorted_points\n",
    "\n",
    "\n",
    "# 假设有两条固定的边\n",
    "fixed_edge_1 = np.array([[19.3, 0.73], [19.3, -0.73]])  # 第一条固定边\n",
    "fixed_edge_2 = np.array([[-19.3, 0.73], [-19.3, -0.73]])  # 第二条固定边\n",
    "\n",
    "\n",
    "    \n",
    "\n",
    "polygon, sorted_points = generate_polygon_with_fixed_edges([fixed_edge_1, fixed_edge_2], num_random_vertices=5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  0.4 , -18.5 ],\n",
       "       [ 16.  , -10.  ],\n",
       "       [ 13.3 ,  -6.3 ],\n",
       "       [ 19.3 ,  -0.73],\n",
       "       [ 19.3 ,   0.73],\n",
       "       [ -2.5 ,   5.7 ],\n",
       "       [-17.2 ,  14.1 ],\n",
       "       [-19.3 ,   0.73],\n",
       "       [-19.3 ,  -0.73]])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted_points"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/svg+xml": [
       "<svg xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" width=\"100.0\" height=\"100.0\" viewBox=\"-20.844 -20.544 41.688 22.818\" preserveAspectRatio=\"xMinYMin meet\"><g transform=\"matrix(1,0,0,-1,0,-18.27)\"><path fill-rule=\"evenodd\" fill=\"#66cc99\" stroke=\"#555555\" stroke-width=\"0.8337600000000001\" opacity=\"0.6\" d=\"M -19.0,-19.0 L -10.0,-19.0 L -10.0,-19.0 L -1.0,-19.0 L 17.0,-10.0 L 19.3,-0.73 L 19.3,0.73 L -19.3,0.73 L -19.3,-0.73 L -19.0,-19.0 z\" /></g></svg>"
      ],
      "text/plain": [
       "<POLYGON ((-19 -19, -10 -19, -10 -19, -1 -19, 17 -10, 19.3 -0.73, 19.3 0.73,...>"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "ename": "",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31mThe Kernel crashed while executing code in the current cell or a previous cell. \n",
      "\u001b[1;31mPlease review the code in the cell(s) to identify a possible cause of the failure. \n",
      "\u001b[1;31mClick <a href='https://aka.ms/vscodeJupyterKernelCrash'>here</a> for more info. \n",
      "\u001b[1;31mView Jupyter <a href='command:jupyter.viewOutput'>log</a> for further details."
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "from shapely.geometry import Polygon\n",
    "\n",
    "def generate_polygon_with_fixed_edges(fixed_edges, num_random_vertices=4):\n",
    "    # 提取固定边的顶点\n",
    "    fixed_points = np.vstack(fixed_edges)\n",
    "    \n",
    "    # 在 -19 到 19 之间生成间隔为 0.1 的点\n",
    "    x_values = np.arange(-19, 19.1, 9)\n",
    "    y_values = np.arange(-19, 19.1, 9)\n",
    "    \n",
    "    # 随机选择 num_random_vertices 个点\n",
    "    random_points = []\n",
    "    while len(random_points) < num_random_vertices:\n",
    "        # 随机选择 x 和 y 坐标\n",
    "        x = np.random.choice(x_values)\n",
    "        y = np.random.choice(y_values)\n",
    "        point = np.array([x, y])\n",
    "        random_points.append(point)\n",
    "    \n",
    "    random_points = np.array(random_points)\n",
    "    \n",
    "    # 将固定的点和随机点合并在一起\n",
    "    all_points = np.vstack([fixed_points, random_points])\n",
    "    \n",
    "    # 计算所有点的中心点\n",
    "    center = np.mean(all_points, axis=0)\n",
    "    \n",
    "    # 按照与中心点的角度对所有点进行排序（确保按逆时针方向排列）\n",
    "    angles = np.arctan2(all_points[:, 1] - center[1], all_points[:, 0] - center[0])\n",
    "    sorted_points = all_points[np.argsort(angles)]\n",
    "    \n",
    "    # 使用 shapely 生成 Polygon\n",
    "    polygon = Polygon(sorted_points)\n",
    "    \n",
    "    return polygon, sorted_points\n",
    "\n",
    "\n",
    "# 假设有两条固定的边\n",
    "fixed_edge_1 = np.array([[19.3, 0.73], [19.3, -0.73]])  # 第一条固定边\n",
    "fixed_edge_2 = np.array([[-19.3, 0.73], [-19.3, -0.73]])  # 第二条固定边\n",
    "\n",
    "polygon, sorted_points = generate_polygon_with_fixed_edges([fixed_edge_1, fixed_edge_2], num_random_vertices=5)\n",
    "polygon\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import itertools\n",
    "\n",
    "# 生成 -19 到 19 之间，间隔为 0.1 的点\n",
    "x_values = np.round(np.arange(-18, 18, 9), 1)  # 使用 np.round 保证每个数值精确到小数点后一位\n",
    "\n",
    "# 生成所有的排列，每个排列由 5 个值组成\n",
    "arrangements = itertools.product(x_values, repeat=10)\n",
    "\n",
    "# 打印前 10 个排列示例\n",
    "out=[]\n",
    "for idx, arrangement in enumerate(arrangements):\n",
    "    out.append(arrangement)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1048576"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from pyDOE import oa\n",
    "\n",
    "# 设置变量数和每个变量的水平数\n",
    "num_variables = 10  # 10个变量\n",
    "levels = 4  # 每个变量4个水平\n",
    "\n",
    "# 使用pyDOE生成L16正交表 (L16表示16个实验组合，适用于4个水平和10个变量)\n",
    "# pyDOE支持的正交表可以通过这种方式创建\n",
    "design = oa('L16', num_variables)\n",
    "\n",
    "# 将设计表转换为适当的水平（例如，使用 1,2,3,4表示4个水平）\n",
    "# 这里我们将0,1,2,3映射到 1, 2, 3, 4 之间\n",
    "design = design + 1\n",
    "\n",
    "# 输出设计表\n",
    "print(\"正交设计表（L16）：\\n\")\n",
    "print(design)\n",
    "\n",
    "# 如果你希望进一步定制设计表的输出，可以选择导出到CSV等格式\n",
    "np.savetxt(\"orthogonal_design.csv\", design, delimiter=\",\", fmt=\"%d\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pyDOE import lhs\n",
    "import numpy as np\n",
    "\n",
    "# 假设我们有10个变量，每个变量需要采样100个样本\n",
    "num_variables = 10\n",
    "num_samples = 100\n",
    "\n",
    "# 使用拉丁超立方体采样生成样本\n",
    "samples = lhs(num_variables, samples=num_samples)\n",
    "\n",
    "# 结果是一个100x10的矩阵，表示10个变量的100个样本\n",
    "print(samples)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "ename": "ImportError",
     "evalue": "cannot import name 'oa' from 'pyDOE' (c:\\Users\\leo_l\\.conda\\envs\\cst\\lib\\site-packages\\pyDOE\\__init__.py)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mImportError\u001b[0m                               Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[4], line 2\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mnumpy\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m \u001b[38;5;21;01mnp\u001b[39;00m\n\u001b[1;32m----> 2\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mpyDOE\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m oa\n\u001b[0;32m      4\u001b[0m \u001b[38;5;66;03m# 设置变量数和每个变量的水平数\u001b[39;00m\n\u001b[0;32m      5\u001b[0m num_variables \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m5\u001b[39m  \u001b[38;5;66;03m# 5个变量\u001b[39;00m\n",
      "\u001b[1;31mImportError\u001b[0m: cannot import name 'oa' from 'pyDOE' (c:\\Users\\leo_l\\.conda\\envs\\cst\\lib\\site-packages\\pyDOE\\__init__.py)"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "from pyDOE import oa\n",
    "\n",
    "# 设置变量数和每个变量的水平数\n",
    "num_variables = 5  # 5个变量\n",
    "levels = 3  # 每个变量3个水平\n",
    "\n",
    "# 使用pyDOE生成L9正交表 (L9表示9个实验组合，适用于3个水平和5个变量)\n",
    "# L9正交表可以保证在进行5个变量的实验时，能够高效地覆盖这些变量的组合\n",
    "design = oa('L9', num_variables)\n",
    "\n",
    "# 将设计表转换为适当的水平（例如，使用 1,2,3表示3个水平）\n",
    "# 这里我们将0,1,2映射到 1, 2, 3之间\n",
    "design = design + 1\n",
    "\n",
    "# 输出设计表\n",
    "print(\"正交设计表（L9）：\\n\")\n",
    "print(design)\n",
    "\n",
    "# 如果你希望进一步定制设计表的输出，可以选择导出到CSV等格式\n",
    "np.savetxt(\"orthogonal_design.csv\", design, delimiter=\",\", fmt=\"%d\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from pyDOE2 import fullfact\n",
    "\n",
    "# 设置变量数和每个变量的水平数\n",
    "num_variables = 5  # 5个变量\n",
    "levels = 3  # 每个变量3个水平\n",
    "\n",
    "# 使用fullfact函数生成正交表\n",
    "# fullfact生成的是一个笛卡尔积的正交表，适用于3个水平和5个变量\n",
    "design = fullfact([levels] * num_variables)\n",
    "\n",
    "# 将设计表转换为适当的水平（例如，使用 1, 2, 3表示3个水平）\n",
    "# 这里我们将0,1,2映射到 1, 2, 3之间\n",
    "design = design + 1\n",
    "\n",
    "# 输出设计表\n",
    "print(\"正交设计表：\\n\")\n",
    "print(design)\n",
    "\n",
    "# 如果你希望进一步定制设计表的输出，可以选择导出到CSV等格式\n",
    "np.savetxt(\"orthogonal_design.csv\", design, delimiter=\",\", fmt=\"%d\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "ename": "ImportError",
     "evalue": "cannot import name 'oa' from 'pyDOE2' (c:\\Users\\leo_l\\.conda\\envs\\cst\\lib\\site-packages\\pyDOE2\\__init__.py)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mImportError\u001b[0m                               Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[8], line 2\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mnumpy\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m \u001b[38;5;21;01mnp\u001b[39;00m\n\u001b[1;32m----> 2\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mpyDOE2\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m oa\n\u001b[0;32m      4\u001b[0m \u001b[38;5;66;03m# 设置变量数和每个变量的水平数\u001b[39;00m\n\u001b[0;32m      5\u001b[0m num_variables \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m5\u001b[39m  \u001b[38;5;66;03m# 例如：5个变量\u001b[39;00m\n",
      "\u001b[1;31mImportError\u001b[0m: cannot import name 'oa' from 'pyDOE2' (c:\\Users\\leo_l\\.conda\\envs\\cst\\lib\\site-packages\\pyDOE2\\__init__.py)"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "from pyDOE2 import oa\n",
    "\n",
    "# 设置变量数和每个变量的水平数\n",
    "num_variables = 5  # 例如：5个变量\n",
    "levels = 3  # 每个变量3个水平\n",
    "\n",
    "# 生成L9正交表\n",
    "# L9表示9个实验组合，适用于3个水平和5个变量\n",
    "design = oa('L9', num_variables)\n",
    "\n",
    "# 将设计表转换为适当的水平（例如，使用 1, 2, 3表示3个水平）\n",
    "# 这里我们将0,1,2映射到 1, 2, 3之间\n",
    "design = design + 1\n",
    "\n",
    "# 输出设计表\n",
    "print(\"正交设计表（L9）：\\n\")\n",
    "print(design)\n",
    "\n",
    "# 可选择将结果保存为CSV文件\n",
    "np.savetxt(\"orthogonal_design.csv\", design, delimiter=\",\", fmt=\"%d\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pyDOE2\n",
    "\n",
    "levels = [2, 3, 4]  # Three factors with 2, 3 or 4 levels respectively.\n",
    "reduction = 2       # Reduce the number of experiments to approximately a third.\n",
    "\n",
    "pyDOE2.gsd(levels, reduction)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "正交设计表：\n",
      "\n",
      "[[1. 1. 1. 1. 1.]\n",
      " [2. 1. 1. 1. 1.]\n",
      " [3. 1. 1. 1. 1.]\n",
      " ...\n",
      " [1. 3. 3. 3. 3.]\n",
      " [2. 3. 3. 3. 3.]\n",
      " [3. 3. 3. 3. 3.]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "from pyDOE2 import fullfact\n",
    "\n",
    "# 定义正交表设计函数\n",
    "def create_orthogonal_table(num_variables, levels):\n",
    "    \"\"\"\n",
    "    创建正交设计表\n",
    "    :param num_variables: 变量的数量\n",
    "    :param levels: 每个变量的水平数\n",
    "    :return: 正交设计表\n",
    "    \"\"\"\n",
    "    # 使用fullfact生成正交表，fullfact生成的是一个笛卡尔积的正交表\n",
    "    design = fullfact([levels] * num_variables)\n",
    "    \n",
    "    # 将设计表转换为适当的水平（从0,1,2映射到1,2,3等）\n",
    "    design = design + 1\n",
    "    \n",
    "    return design\n",
    "\n",
    "# 设置变量数和每个变量的水平数\n",
    "num_variables = 5  # 例如：5个变量\n",
    "levels = 3  # 每个变量3个水平\n",
    "\n",
    "# 生成正交设计表\n",
    "orthogonal_table = create_orthogonal_table(num_variables, levels)\n",
    "\n",
    "# 输出设计表\n",
    "print(\"正交设计表：\\n\")\n",
    "print(orthogonal_table)\n",
    "\n",
    "# 可选择将结果保存为CSV文件\n",
    "np.savetxt(\"orthogonal_design.csv\", orthogonal_table, delimiter=\",\", fmt=\"%d\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pressure had more than two levels. Assigning the end point to the high level.\n",
      "Temperature had more than two levels. Assigning the end point to the high level.\n",
      "Flow rate had more than two levels. Assigning the end point to the high level.\n",
      "Time had more than two levels. Assigning the end point to the high level.\n",
      "qwe had more than two levels. Assigning the end point to the high level.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Pressure</th>\n",
       "      <th>Temperature</th>\n",
       "      <th>Flow rate</th>\n",
       "      <th>Time</th>\n",
       "      <th>qwe</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>-18.0</td>\n",
       "      <td>-18.0</td>\n",
       "      <td>-18.0</td>\n",
       "      <td>18.0</td>\n",
       "      <td>18.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>18.0</td>\n",
       "      <td>-18.0</td>\n",
       "      <td>-18.0</td>\n",
       "      <td>-18.0</td>\n",
       "      <td>-18.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>-18.0</td>\n",
       "      <td>18.0</td>\n",
       "      <td>-18.0</td>\n",
       "      <td>-18.0</td>\n",
       "      <td>18.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>18.0</td>\n",
       "      <td>18.0</td>\n",
       "      <td>-18.0</td>\n",
       "      <td>18.0</td>\n",
       "      <td>-18.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>-18.0</td>\n",
       "      <td>-18.0</td>\n",
       "      <td>18.0</td>\n",
       "      <td>18.0</td>\n",
       "      <td>-18.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>18.0</td>\n",
       "      <td>-18.0</td>\n",
       "      <td>18.0</td>\n",
       "      <td>-18.0</td>\n",
       "      <td>18.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>-18.0</td>\n",
       "      <td>18.0</td>\n",
       "      <td>18.0</td>\n",
       "      <td>-18.0</td>\n",
       "      <td>-18.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>18.0</td>\n",
       "      <td>18.0</td>\n",
       "      <td>18.0</td>\n",
       "      <td>18.0</td>\n",
       "      <td>18.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Pressure  Temperature  Flow rate  Time   qwe\n",
       "0     -18.0        -18.0      -18.0  18.0  18.0\n",
       "1      18.0        -18.0      -18.0 -18.0 -18.0\n",
       "2     -18.0         18.0      -18.0 -18.0  18.0\n",
       "3      18.0         18.0      -18.0  18.0 -18.0\n",
       "4     -18.0        -18.0       18.0  18.0 -18.0\n",
       "5      18.0        -18.0       18.0 -18.0  18.0\n",
       "6     -18.0         18.0       18.0 -18.0 -18.0\n",
       "7      18.0         18.0       18.0  18.0  18.0"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from doepy import build\n",
    "\n",
    "build.build_frac_fact_res(\n",
    "{'Pressure':[-18,-9,0,9,18],\n",
    "'Temperature':[-18,-9,0,9,18],\n",
    "'Flow rate':[-18,-9,0,9,18],\n",
    "'Time':[-18,-9,0,9,18],\n",
    "'qwe':[-18,-9,0,9,18]}\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "# 原始的 L16 正交实验设计矩阵\n",
    "data = [\n",
    "    [1, 1, 1, 1, 1, 1, 1, 1, 1, 1],\n",
    "    [1, 1, 2, 2, 2, 2, 2, 2, 2, 2],\n",
    "    [1, 1, 3, 3, 3, 3, 3, 3, 3, 3],\n",
    "    [1, 1, 4, 4, 4, 4, 4, 4, 4, 4],\n",
    "    [2, 2, 1, 2, 3, 3, 3, 4, 4, 1],\n",
    "    [2, 2, 2, 3, 4, 1, 4, 1, 3, 2],\n",
    "    [2, 2, 3, 4, 1, 2, 1, 3, 4, 3],\n",
    "    [2, 2, 4, 1, 2, 3, 2, 4, 1, 4],\n",
    "    [3, 3, 1, 3, 2, 4, 3, 2, 1, 4],\n",
    "    [3, 3, 2, 4, 3, 1, 4, 3, 2, 1],\n",
    "    [3, 3, 3, 1, 4, 2, 1, 4, 3, 2],\n",
    "    [3, 3, 4, 2, 1, 3, 2, 1, 4, 3],\n",
    "    [4, 4, 1, 4, 1, 2, 4, 3, 2, 4],\n",
    "    [4, 4, 2, 1, 2, 4, 1, 4, 3, 1],\n",
    "    [4, 4, 3, 2, 3, 1, 2, 2, 4, 2],\n",
    "    [4, 4, 4, 3, 4, 3, 3, 1, 2, 3]\n",
    "]\n",
    "\n",
    "# 将数据转换为 NumPy 数组\n",
    "orthogonal_matrix = np.array(data)\n",
    "\n",
    "# 转换每一行的元素为[[x, x], [x, x], ...]\n",
    "converted_matrix = []\n",
    "\n",
    "for row in orthogonal_matrix:\n",
    "    # 对每行的每个元素创建二维数组\n",
    "    converted_row = [[x, x] for x in row]\n",
    "    converted_matrix.append(converted_row)\n",
    "\n",
    "# 转换后的矩阵是嵌套的二维列表\n",
    "converted_matrix = np.array(converted_matrix)\n",
    "# 定义转换字典\n",
    "conversion_dict = {1: -18, 2: -9, 3: 9, 4: 18}\n",
    "\n",
    "# 使用 np.vectorize 进行元素替换\n",
    "vectorized_conversion = np.vectorize(lambda x: conversion_dict[x])\n",
    "\n",
    "converted_matrix=vectorized_conversion(converted_matrix)\n",
    "# 输出转换后的矩阵\n",
    "print(\"转换后的矩阵：\\n\")\n",
    "print(converted_matrix)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "转换后的矩阵：\n",
      "\n",
      "[[-18 -18 -18 -18 -18 -18 -18 -18 -18 -18]\n",
      " [-18 -18  -9  -9  -9  -9  -9  -9  -9  -9]\n",
      " [-18 -18   9   9   9   9   9   9   9   9]\n",
      " [-18 -18  18  18  18  18  18  18  18  18]\n",
      " [ -9  -9 -18  -9   9   9   9  18  18 -18]\n",
      " [ -9  -9  -9   9  18 -18  18 -18   9  -9]\n",
      " [ -9  -9   9  18 -18  -9 -18   9  18   9]\n",
      " [ -9  -9  18 -18  -9   9  -9  18 -18  18]\n",
      " [  9   9 -18   9  -9  18   9  -9 -18  18]\n",
      " [  9   9  -9  18   9 -18  18   9  -9 -18]\n",
      " [  9   9   9 -18  18  -9 -18  18   9  -9]\n",
      " [  9   9  18  -9 -18   9  -9 -18  18   9]\n",
      " [ 18  18 -18  18 -18  -9  18   9  -9  18]\n",
      " [ 18  18  -9 -18  -9  18 -18  18   9 -18]\n",
      " [ 18  18   9  -9   9 -18  -9  -9  18  -9]\n",
      " [ 18  18  18   9  18   9   9 -18  -9   9]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "# 原始的 L16 正交实验设计矩阵\n",
    "data = [\n",
    "    [1, 1, 1, 1, 1, 1, 1, 1, 1, 1],\n",
    "    [1, 1, 2, 2, 2, 2, 2, 2, 2, 2],\n",
    "    [1, 1, 3, 3, 3, 3, 3, 3, 3, 3],\n",
    "    [1, 1, 4, 4, 4, 4, 4, 4, 4, 4],\n",
    "    [2, 2, 1, 2, 3, 3, 3, 4, 4, 1],\n",
    "    [2, 2, 2, 3, 4, 1, 4, 1, 3, 2],\n",
    "    [2, 2, 3, 4, 1, 2, 1, 3, 4, 3],\n",
    "    [2, 2, 4, 1, 2, 3, 2, 4, 1, 4],\n",
    "    [3, 3, 1, 3, 2, 4, 3, 2, 1, 4],\n",
    "    [3, 3, 2, 4, 3, 1, 4, 3, 2, 1],\n",
    "    [3, 3, 3, 1, 4, 2, 1, 4, 3, 2],\n",
    "    [3, 3, 4, 2, 1, 3, 2, 1, 4, 3],\n",
    "    [4, 4, 1, 4, 1, 2, 4, 3, 2, 4],\n",
    "    [4, 4, 2, 1, 2, 4, 1, 4, 3, 1],\n",
    "    [4, 4, 3, 2, 3, 1, 2, 2, 4, 2],\n",
    "    [4, 4, 4, 3, 4, 3, 3, 1, 2, 3]\n",
    "]\n",
    "\n",
    "# 创建 NumPy 数组\n",
    "orthogonal_matrix = np.array(data)\n",
    "\n",
    "# 定义转换字典\n",
    "conversion_dict = {1: -18, 2: -9, 3: 9, 4: 18}\n",
    "\n",
    "# 使用 np.vectorize 进行元素替换\n",
    "vectorized_conversion = np.vectorize(lambda x: conversion_dict[x])\n",
    "\n",
    "# 转换矩阵\n",
    "converted_matrix = vectorized_conversion(orthogonal_matrix)\n",
    "\n",
    "# 输出转换后的矩阵\n",
    "print(\"转换后的矩阵：\\n\")\n",
    "print(converted_matrix)\n",
    "\n",
    "# 可选择将转换后的矩阵保存为 CSV 文件\n",
    "np.savetxt(\"converted_L16_orthogonal_design.csv\", converted_matrix, delimiter=\",\", fmt=\"%d\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 画obj"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "\n",
    "def load_obj(filename):\n",
    "    vertices = []\n",
    "    faces = []\n",
    "    with open(filename, 'r') as file:\n",
    "        for line in file:\n",
    "            if line.startswith('v '):\n",
    "                parts = line.split()\n",
    "                vertices.append([float(parts[1]), float(parts[2]), float(parts[3])])\n",
    "            elif line.startswith('f '):\n",
    "                parts = line.split()\n",
    "                face = [int(part.split('/')[0]) - 1 for part in parts[1:]]\n",
    "                faces.append(face)\n",
    "    return vertices, faces\n",
    "\n",
    "def plot_obj(vertices, faces):\n",
    "    fig = plt.figure()\n",
    "    ax = fig.add_subplot(111, projection='3d')\n",
    "    \n",
    "    for face in faces:\n",
    "        face_vertices = [vertices[idx] for idx in face]\n",
    "        face_vertices.append(face_vertices[0])  # Close the face\n",
    "        xs, ys, zs = zip(*face_vertices)\n",
    "        ax.plot(xs, ys, zs, color='b')\n",
    "    \n",
    "    ax.set_xlabel('X')\n",
    "    ax.set_ylabel('Y')\n",
    "    ax.set_zlabel('Z')\n",
    "    plt.show()\n",
    "\n",
    "# 使用示例\n",
    "vertices, faces = load_obj('C:\\Reaserch\\Code\\CEM\\AntennaGPT\\data\\gap\\data4.obj')\n",
    "plot_obj(vertices, faces)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.20"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
